Utilities

/**
 * Creates a File-like object from a stream with a given name
 * @param stream - The stream to convert to a File
 * @param name - The name/filename for the File
 * @param options - Additional options for file creation
 * @returns Promise that resolves to a File-like object
 */
function createFileFromStream(
  stream: ReadableStream<Uint8Array> | NodeJS.ReadableStream,
  name: string,
  options?: CreateFileFromStreamOptions
): Promise<File>;

/**
 * Creates a File-like object from various input types
 * @param data - The data to convert to a File
 * @param name - The name/filename for the File
 * @param options - Additional options for file creation
 * @returns File-like object
 */
function createFile(
  data: string | Uint8Array | ArrayBuffer | Blob,
  name: string,
  options?: CreateFileOptions
): File;

interface CreateFileFromStreamOptions {
  /**
   * The MIME type of the file
   */
  type?: string;
  
  /**
   * The last modified timestamp
   */
  lastModified?: number;
}

interface CreateFileOptions {
  /**
   * The MIME type of the file
   */
  type?: string;
  
  /**
   * The last modified timestamp
   */
  lastModified?: number;
}

import { 
  createFile, 
  createFileFromStream,
  createPipelineRequest,
  type CreateFileOptions 
} from "@azure/core-rest-pipeline";
import * as fs from "fs";

// Create file from string data
const textFile = createFile(
  "Hello, World!",
  "greeting.txt",
  { type: "text/plain" }
);

// Create file from binary data
const binaryData = new Uint8Array([0x89, 0x50, 0x4E, 0x47]); // PNG header
const imageFile = createFile(
  binaryData,
  "image.png",
  { 
    type: "image/png",
    lastModified: Date.now()
  }
);

// Create file from stream (Node.js)
const fileStream = fs.createReadStream("document.pdf");
const streamFile = await createFileFromStream(
  fileStream,
  "document.pdf",
  { type: "application/pdf" }
);

// Use in form data
const request = createPipelineRequest({
  url: "https://api.example.com/upload",
  method: "POST",
  formData: {
    textFile,
    imageFile,
    document: streamFile
  }
});

// File creation patterns for different data types

// From JSON data
const jsonFile = createFile(
  JSON.stringify({ name: "example", data: [1, 2, 3] }),
  "data.json",
  { type: "application/json" }
);

// From ArrayBuffer
const arrayBuffer = new ArrayBuffer(1024);
const bufferFile = createFile(
  arrayBuffer,
  "buffer.bin",
  { type: "application/octet-stream" }
);

// From existing Blob
const blob = new Blob(["file content"], { type: "text/plain" });
const blobFile = createFile(
  blob,
  "blob.txt",
  { type: "text/plain" }
);

import { createFile, createFileFromStream } from "@azure/core-rest-pipeline";

// File upload utility function
async function createUploadFile(
  data: string | Uint8Array | ArrayBuffer | Blob | ReadableStream | NodeJS.ReadableStream,
  filename: string,
  mimeType?: string
): Promise<File> {
  const options = { type: mimeType, lastModified: Date.now() };
  
  if (data instanceof ReadableStream || (data as any).pipe) {
    // Handle streams
    return await createFileFromStream(data as any, filename, options);
  } else {
    // Handle direct data
    return createFile(data as any, filename, options);
  }
}

// Usage in file upload scenarios
const files = await Promise.all([
  createUploadFile("CSV data here", "data.csv", "text/csv"),
  createUploadFile(new Uint8Array([1, 2, 3]), "binary.dat", "application/octet-stream"),
  createUploadFile(jsonData, "config.json", "application/json")
]);

// Upload multiple files
const uploadRequest = createPipelineRequest({
  url: "https://api.example.com/batch-upload",
  method: "POST",
  formData: {
    files: files // Array of files
  }
});

import { 
  createFile,
  createFileFromStream,
  createPipelineRequest,
  createHttpHeaders,
  type MultipartRequestBody,
  type BodyPart
} from "@azure/core-rest-pipeline";

// Create multipart request with files
async function createMultipartUpload() {
  // Create files from different sources
  const textFile = createFile("Document content", "readme.txt", { type: "text/plain" });
  const jsonFile = createFile(
    JSON.stringify({ version: "1.0", author: "user" }),
    "metadata.json",
    { type: "application/json" }
  );

  // Create multipart body
  const parts: BodyPart[] = [
    {
      headers: createHttpHeaders({
        "Content-Disposition": 'form-data; name="description"'
      }),
      body: "File upload description"
    },
    {
      headers: createHttpHeaders({
        "Content-Disposition": 'form-data; name="textFile"; filename="readme.txt"',
        "Content-Type": "text/plain"
      }),
      body: textFile
    },
    {
      headers: createHttpHeaders({
        "Content-Disposition": 'form-data; name="metadata"; filename="metadata.json"',
        "Content-Type": "application/json"
      }),
      body: jsonFile
    }
  ];

  const multipartBody: MultipartRequestBody = {
    parts,
    boundary: "upload-boundary-123"
  };

  return createPipelineRequest({
    url: "https://api.example.com/multipart-upload",
    method: "POST",
    multipartBody
  });
}

// File processing utilities
class FileUtils {
  /**
   * Create a file from base64 encoded data
   */
  static createFileFromBase64(
    base64Data: string,
    filename: string,
    mimeType: string
  ): File {
    // Remove data URL prefix if present
    const base64 = base64Data.replace(/^data:[^;]+;base64,/, '');
    
    // Convert base64 to binary
    const binary = atob(base64);
    const bytes = new Uint8Array(binary.length);
    for (let i = 0; i < binary.length; i++) {
      bytes[i] = binary.charCodeAt(i);
    }
    
    return createFile(bytes, filename, { type: mimeType });
  }

  /**
   * Create a CSV file from array data
   */
  static createCSVFile(
    data: Record<string, any>[],
    filename: string
  ): File {
    if (data.length === 0) {
      return createFile("", filename, { type: "text/csv" });
    }

    // Generate CSV content
    const headers = Object.keys(data[0]);
    const csvRows = [
      headers.join(","),
      ...data.map(row => 
        headers.map(header => {
          const value = row[header];
          const escaped = String(value).replace(/"/g, '""');
          return `"${escaped}"`;
        }).join(",")
      )
    ];
    
    const csvContent = csvRows.join("\n");
    return createFile(csvContent, filename, { type: "text/csv" });
  }

  /**
   * Create a JSON file from object data
   */
  static createJSONFile(
    data: any,
    filename: string,
    pretty = false
  ): File {
    const jsonContent = pretty 
      ? JSON.stringify(data, null, 2)
      : JSON.stringify(data);
    
    return createFile(jsonContent, filename, { type: "application/json" });
  }
}

// Usage examples
const base64Image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==";
const imageFile = FileUtils.createFileFromBase64(base64Image, "pixel.png", "image/png");

const csvData = [
  { name: "Alice", age: 30, city: "New York" },
  { name: "Bob", age: 25, city: "San Francisco" }
];
const csvFile = FileUtils.createCSVFile(csvData, "users.csv");

const configData = { version: "1.0", debug: true, features: ["auth", "logging"] };
const configFile = FileUtils.createJSONFile(configData, "config.json", true);

import { createFile, createFileFromStream, isRestError } from "@azure/core-rest-pipeline";

async function safeFileUpload(
  data: string | Uint8Array | ReadableStream,
  filename: string,
  maxSize = 10 * 1024 * 1024 // 10MB
) {
  try {
    // Sanitize filename
    const safeName = filename.replace(/[^a-zA-Z0-9.-]/g, '_');
    
    // Create file
    let file: File;
    if (data instanceof ReadableStream) {
      file = await createFileFromStream(data, safeName);
    } else {
      // Check size for direct data
      const size = typeof data === 'string' ? data.length : data.byteLength;
      if (size > maxSize) {
        throw new Error(`File too large: ${size} bytes exceeds ${maxSize} bytes`);
      }
      file = createFile(data, safeName);
    }
    
    return file;
  } catch (error) {
    console.error("File creation failed:", error);
    throw error;
  }
}