a simple way for
developers
to store files

function uploadFile(localPath: string, pathOnShard: string): Promise<void> {
    const stats = fs.statSync(localPath);
    const stream = fs.createReadStream(localPath);

    const url = new URL(`${SHARD_URL}/fso`);
    url.searchParams.set('path', pathOnShard);

    return new Promise((resolve, reject) => {
        const req = http.request({
            hostname: url.hostname,
            port: url.port,
            path: url.pathname + url.search,
            method: 'POST',
            headers: {
                'x-user-api-key': API_KEY,
                'Content-Type': 'application/octet-stream',
                'Content-Length': stats.size
            }
        }, (res) => {
            let body = '';
            res.on('data', chunk => body += chunk);
            res.on('end', () => {
                res.statusCode === 201 ? resolve() : reject(new Error(`${res.statusCode}: ${body}`));
            });
        });

        req.on('error', reject);
        stream.on('error', reject);
        stream.pipe(req);
    });
}

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "os"
    "io"
)

const API_KEY = "YOUR-API-KEY"
const SHARD_NODE_URL = "https://YOUR-NODE-URL"

func UploadFile(localFilePath string, pathOnShard string) {
    f, err := os.Open(localFilePath)
    if err != nil {
        panic(fmt.Errorf("could not open file: %w", err))
    }
    defer f.Close()
    
    url := fmt.Sprintf("%s/fso?path=%s", SHARD_NODE_URL, url.QueryEscape(pathOnShard))
    req, err := http.NewRequest(http.MethodPost, url, f)
    if err != nil {
        panic(fmt.Errorf("could not create upload request: %w", err))
    }
    
    req.Header.Set("x-user-api-key", API_KEY)
    req.Header.Set("Content-Type", "application/octet-stream") 
    
    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        panic(fmt.Errorf("error uploading file: %w", err))
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusCreated {
        body, _ := io.ReadAll(resp.Body)
        panic(fmt.Sprintf("Upload failed with status %d: %s", resp.StatusCode, string(body)))
    }
    
}