vectra 0.12.2 → 0.14.0

package/src/server/handlers/itemHandlers.ts

@@ -0,0 +1,140 @@
+import * as grpc from '@grpc/grpc-js';
+import { v4 } from 'uuid';
+import { LocalIndex } from '../../LocalIndex';
+import { IndexManager } from '../IndexManager';
+import { EmbeddingsModel, IndexItem } from '../../types';
+import { wrapHandler, grpcError, fromProtoMetadata, toProtoMetadata, parseFilterJson } from './helpers';
+
+async function resolveVector(
+    text: string | undefined,
+    vector: number[] | undefined,
+    embeddings: EmbeddingsModel | undefined
+): Promise<number[]> {
+    if (vector && vector.length > 0) {
+        return vector;
+    }
+    if (text && text.length > 0) {
+        if (!embeddings) {
+            throw grpcError(grpc.status.FAILED_PRECONDITION, 'No embeddings model configured on the server');
+        }
+        const response = await embeddings.createEmbeddings(text);
+        if (response.status !== 'success' || !response.output) {
+            throw grpcError(grpc.status.INTERNAL, `Embeddings error: ${response.message || 'unknown'}`);
+        }
+        return response.output[0];
+    }
+    throw grpcError(grpc.status.INVALID_ARGUMENT, 'Either text or vector must be provided');
+}
+
+function asLocalIndex(managed: { index: LocalIndex | any }): LocalIndex {
+    return managed.index as LocalIndex;
+}
+
+function itemToProto(item: IndexItem) {
+    return {
+        id: item.id,
+        metadata: toProtoMetadata(item.metadata as Record<string, any>),
+        vector: Array.from(item.vector),
+        norm: item.norm,
+        score: 0,
+    };
+}
+
+export function createItemHandlers(manager: IndexManager, embeddings?: EmbeddingsModel) {
+    return {
+        InsertItem: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            const vector = await resolveVector(req.text, req.vector, embeddings);
+            const metadata = fromProtoMetadata(req.metadata);
+            const id = req.id || v4();
+
+            const item = await idx.insertItem({ id, vector, metadata });
+            return { id: item.id };
+        }),
+
+        UpsertItem: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            if (!req.id) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'id is required for upsert');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            const vector = await resolveVector(req.text, req.vector, embeddings);
+            const metadata = fromProtoMetadata(req.metadata);
+
+            const item = await idx.upsertItem({ id: req.id, vector, metadata });
+            return { id: item.id };
+        }),
+
+        BatchInsertItems: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            const items = req.items || [];
+            const toInsert: Array<Partial<IndexItem>> = [];
+
+            for (const item of items) {
+                const vector = await resolveVector(item.text, item.vector, embeddings);
+                const metadata = fromProtoMetadata(item.metadata);
+                toInsert.push({ id: item.id || v4(), vector, metadata });
+            }
+
+            const inserted = await idx.batchInsertItems(toInsert);
+            return { ids: inserted.map((i: IndexItem) => i.id) };
+        }),
+
+        GetItem: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            if (!req.id) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'id is required');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            const item = await idx.getItem(req.id);
+            if (!item) {
+                throw grpcError(grpc.status.NOT_FOUND, `Item not found: ${req.id}`);
+            }
+            return { item: itemToProto(item) };
+        }),
+
+        DeleteItem: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            if (!req.id) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'id is required');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            await idx.deleteItem(req.id);
+            return {};
+        }),
+
+        ListItems: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const idx = asLocalIndex(manager.requireIndex(req.index_name));
+            const filter = parseFilterJson(req.filter);
+
+            const items = filter
+                ? await idx.listItemsByMetadata(filter)
+                : await idx.listItems();
+
+            return {
+                items: items.map((item: IndexItem) => itemToProto(item)),
+            };
+        }),
+    };
+}

package/src/server/handlers/lifecycleHandlers.ts

@@ -0,0 +1,26 @@
+import * as grpc from '@grpc/grpc-js';
+import { IndexManager } from '../IndexManager';
+import { wrapHandler } from './helpers';
+
+export function createLifecycleHandlers(
+    manager: IndexManager,
+    startTime: number,
+    onShutdown: () => void
+) {
+    return {
+        Healthcheck: wrapHandler(async (_call: grpc.ServerUnaryCall<any, any>) => {
+            const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000);
+            return {
+                status: 'ok',
+                uptime_seconds: uptimeSeconds,
+                loaded_indexes: manager.indexes.size,
+            };
+        }),
+
+        Shutdown: wrapHandler(async (_call: grpc.ServerUnaryCall<any, any>) => {
+            // Trigger graceful shutdown asynchronously
+            process.nextTick(onShutdown);
+            return {};
+        }),
+    };
+}

package/src/server/handlers/queryHandlers.ts

@@ -0,0 +1,96 @@
+import * as grpc from '@grpc/grpc-js';
+import { LocalIndex } from '../../LocalIndex';
+import { IndexManager } from '../IndexManager';
+import { EmbeddingsModel, QueryResult } from '../../types';
+import { wrapHandler, grpcError, toProtoMetadata, parseFilterJson } from './helpers';
+
+export function createQueryHandlers(manager: IndexManager, embeddings?: EmbeddingsModel) {
+    return {
+        QueryItems: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const idx = manager.requireIndex(req.index_name).index as LocalIndex;
+            const topK = req.top_k || 10;
+            const filter = parseFilterJson(req.filter);
+
+            let vector: number[];
+            if (req.vector && req.vector.length > 0) {
+                vector = req.vector;
+            } else if (req.text && req.text.length > 0) {
+                if (!embeddings) {
+                    throw grpcError(grpc.status.FAILED_PRECONDITION, 'No embeddings model configured on the server');
+                }
+                const response = await embeddings.createEmbeddings(req.text);
+                if (response.status !== 'success' || !response.output) {
+                    throw grpcError(grpc.status.INTERNAL, `Embeddings error: ${response.message || 'unknown'}`);
+                }
+                vector = response.output[0];
+            } else {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'Either text or vector must be provided');
+            }
+
+            const results = await idx.queryItems(vector, req.text || '', topK, filter);
+            return {
+                results: results.map((r: QueryResult) => ({
+                    id: r.item.id,
+                    metadata: toProtoMetadata(r.item.metadata as Record<string, any>),
+                    vector: Array.from(r.item.vector),
+                    norm: r.item.norm,
+                    score: r.score,
+                })),
+            };
+        }),
+
+        QueryDocuments: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const { docIndex } = manager.requireDocumentIndex(req.index_name);
+            if (!req.query) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'query is required');
+            }
+
+            const filter = parseFilterJson(req.filter);
+            const results = await docIndex.queryDocuments(req.query, {
+                maxDocuments: req.max_documents || 10,
+                maxChunks: req.max_chunks || 50,
+                filter,
+                isBm25: req.use_bm25 || false,
+            });
+
+            const protoResults = [];
+            for (const result of results) {
+                const chunks = [];
+                for (const chunk of result.chunks) {
+                    const text = await (async () => {
+                        try {
+                            const doc = result;
+                            const startPos = (chunk.item.metadata as any).startPos || 0;
+                            const endPos = (chunk.item.metadata as any).endPos || 0;
+                            const fullText = await doc.loadText();
+                            return fullText.substring(startPos, endPos + 1);
+                        } catch {
+                            return '';
+                        }
+                    })();
+                    chunks.push({
+                        text,
+                        score: chunk.score,
+                        token_count: 0,
+                    });
+                }
+                protoResults.push({
+                    uri: result.uri,
+                    document_id: result.id,
+                    chunks,
+                    score: result.score,
+                });
+            }
+
+            return { results: protoResults };
+        }),
+    };
+}

package/src/server/handlers/statsHandlers.ts

@@ -0,0 +1,38 @@
+import * as grpc from '@grpc/grpc-js';
+import { IndexManager } from '../IndexManager';
+import { LocalDocumentIndex } from '../../LocalDocumentIndex';
+import { wrapHandler, grpcError } from './helpers';
+
+export function createStatsHandlers(manager: IndexManager) {
+    return {
+        GetIndexStats: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const managed = manager.requireIndex(req.index_name);
+            const stats = await managed.index.getIndexStats();
+            return {
+                version: stats.version,
+                format: managed.format,
+                item_count: stats.items,
+                metadata_config_count: stats.metadata_config?.indexed?.length || 0,
+            };
+        }),
+
+        GetCatalogStats: wrapHandler(async (call: grpc.ServerUnaryCall<any, any>) => {
+            const req = call.request;
+            if (!req.index_name) {
+                throw grpcError(grpc.status.INVALID_ARGUMENT, 'index_name is required');
+            }
+            const { docIndex } = manager.requireDocumentIndex(req.index_name);
+            const stats = await docIndex.getCatalogStats();
+            return {
+                version: stats.version,
+                document_count: stats.documents,
+                chunk_count: stats.chunks,
+                metadata_counts: {},
+            };
+        }),
+    };
+}

package/src/server/index.ts

@@ -0,0 +1,3 @@
+export { VectraServer, VectraServerConfig } from './VectraServer';
+export { IndexManager, IndexManagerConfig, ManagedIndex } from './IndexManager';
+export * from './handlers';

package/src/storage/FileStorage.ts

@@ -0,0 +1,105 @@
+import { FileType } from "./FileType";
+
+/**
+ * Filter to apply when listing files.
+ */
+export type ListFilesFilter = 'files' | 'folders' | 'all';
+
+/**
+ * Interface implemented by storage plugins.
+ */
+export interface FileStorage {
+    /**
+     * Creates a new file with the given path and content.
+     * @remarks
+     * Throws an error if the file already exists.
+     * @param filePath Path to file to create.
+     * @param content Content to write to the file.
+     */
+    createFile(filePath: string, content: Buffer|string): Promise<void>;
+
+    /**
+     * Creates a folder with the given path.
+     * @remarks
+     * Any missing parent folders will also be created.
+     * @param folderPath Path to folder to create.
+     */
+    createFolder(folderPath: string): Promise<void>;
+
+    /**
+     * Deletes the file at the given path if it exists.
+     * @param filePath Path to file to delete.
+     */
+    deleteFile(filePath: string): Promise<void>;
+
+    /**
+     * Deletes the folder at the given path if it exists.
+     * @remarks
+     * All files and folders within the folder will also be deleted.
+     * @param folderPath Path to folder to delete.
+     */
+    deleteFolder(folderPath: string): Promise<void>;
+
+    /**
+     * Returns the details of an existing file or folder.
+     * @remarks
+     * Throws an error if the file or folder does not exist.
+     * @param fileOrFolderPath File or folder path to get details for.
+     * @returns Details of the file or folder.
+     */
+    getDetails(fileOrFolderPath: string): Promise<FileDetails>;
+
+    /**
+     * Lists all files in the given folder.
+     * @param folderPath Folder to list files in.
+     * @param filter Optional. Type of entries to return. Defaults to 'all'.
+     */
+    listFiles(folderPath: string, filter?: ListFilesFilter): Promise<FileDetails[]>;
+
+    /**
+     * Returns true if a file or folder exists at the given path.
+     * @param fileOrFolderPath File or folder path to check.
+     */
+    pathExists(fileOrFolderPath: string): Promise<boolean>;
+
+    /**
+     * Reads the file at the given path.
+     * @param filePath Path to file to read.
+     */
+    readFile(filePath: string): Promise<Buffer>;
+
+    /**
+     * Creates or replaces the file at the given path with the given content.
+     * @param filePath Path to file to write.
+     * @param content Content to write to the file.
+     */
+    upsertFile(filePath: string, content: Buffer|string): Promise<void>;
+}
+
+/**
+ * Details of a file or folder.
+ */
+export interface FileDetails {
+    /**
+     * Name of the file or folder.
+     */
+    name: string;
+
+    /**
+     * Path to the file or folder.
+     */
+    path: string;
+
+    /**
+     * True if the entry is a folder.
+     */
+    isFolder: boolean;
+
+    /**
+     * The files type if known.
+     * @remarks
+     * Based off the file extension. This will be undefined for folders and for extensions that are not
+     * in the `FileExt[]` array. 
+     */
+    fileType?: FileType;
+}

package/src/storage/FileStorageUtilities.spec.ts

@@ -0,0 +1,106 @@
+import assert from 'node:assert/strict';
+import sinon from 'sinon';
+import { FileStorageUtilities } from './FileStorageUtilities';
+import type { FileStorage } from './FileStorage';
+
+describe('FileStorageUtilities', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('ensureFolderExists', () => {
+    it('does not create the folder when it already exists', async () => {
+      const folderPath = '/already/there';
+      const storage = {
+        pathExists: sinon.stub().resolves(true),
+        createFolder: sinon.stub(),
+      } as unknown as FileStorage;
+
+      await FileStorageUtilities.ensureFolderExists(storage, folderPath);
+
+      sinon.assert.calledOnceWithExactly((storage as any).pathExists, folderPath);
+      sinon.assert.notCalled((storage as any).createFolder);
+    });
+
+    it('creates the folder when it does not exist', async () => {
+      const folderPath = '/needs/creation';
+      const storage = {
+        pathExists: sinon.stub().resolves(false),
+        createFolder: sinon.stub().resolves(),
+      } as unknown as FileStorage;
+
+      await FileStorageUtilities.ensureFolderExists(storage, folderPath);
+
+      sinon.assert.calledOnceWithExactly((storage as any).pathExists, folderPath);
+      sinon.assert.calledOnceWithExactly((storage as any).createFolder, folderPath);
+    });
+  });
+
+  describe('getFileType', () => {
+    it('returns type for known extension (lowercase)', () => {
+      assert.strictEqual(FileStorageUtilities.getFileType('/any/path/file.txt'), 'txt');
+    });
+
+    it('returns type for known extension (case-insensitive)', () => {
+      assert.strictEqual(FileStorageUtilities.getFileType('/any/path/FILE.TXT'), 'txt');
+    });
+
+    it('returns undefined for unknown extension', () => {
+      assert.strictEqual(FileStorageUtilities.getFileType('/any/path/file.unknown'), undefined);
+    });
+
+    it('returns undefined when no extension', () => {
+      assert.strictEqual(FileStorageUtilities.getFileType('/any/path/filename'), undefined);
+    });
+
+    it('returns undefined for trailing dot', () => {
+      assert.strictEqual(FileStorageUtilities.getFileType('/any/path/file.'), undefined);
+    });
+  });
+
+  describe('getFileTypeFromContentType', () => {
+    it('returns mapped type when content type is directly mapped', () => {
+      assert.strictEqual(FileStorageUtilities.getFileTypeFromContentType('text/plain'), 'txt');
+    });
+
+    it('falls back to subtype when not directly mapped', () => {
+      // Not directly mapped but subtype is a known extension
+      assert.strictEqual(FileStorageUtilities.getFileTypeFromContentType('application/png'), 'png');
+    });
+
+    it('handles "+" in subtype by using part before plus (may be unknown)', () => {
+      assert.strictEqual(FileStorageUtilities.getFileTypeFromContentType('application/ld+json'), undefined);
+    });
+
+    it('returns undefined for invalid content type format (no slash)', () => {
+      assert.strictEqual(FileStorageUtilities.getFileTypeFromContentType('invalid'), undefined);
+    });
+  });
+
+  describe('tryDeleteFile', () => {
+    it('returns undefined on successful delete', async () => {
+      const filePath = '/tmp/success.bin';
+      const storage = {
+        deleteFile: sinon.stub().resolves(),
+      } as unknown as FileStorage;
+
+      const result = await FileStorageUtilities.tryDeleteFile(storage, filePath);
+
+      sinon.assert.calledOnceWithExactly((storage as any).deleteFile, filePath);
+      assert.strictEqual(result, undefined);
+    });
+
+    it('returns the error on failed delete', async () => {
+      const filePath = '/tmp/fail.bin';
+      const error = new Error('boom');
+      const storage = {
+        deleteFile: sinon.stub().rejects(error),
+      } as unknown as FileStorage;
+
+      const result = await FileStorageUtilities.tryDeleteFile(storage, filePath);
+
+      sinon.assert.calledOnceWithExactly((storage as any).deleteFile, filePath);
+      assert.strictEqual(result, error);
+    });
+  });
+});

package/src/storage/FileStorageUtilities.ts

@@ -0,0 +1,77 @@
+import { FileStorage } from "./FileStorage";
+import { FileExt, FileType, ContentTypeMap } from "./FileType";
+import { pathUtils as path } from '../utils/pathUtils';
+/**
+ * Utility functions for working with FileStorage abstractions.
+ */
+export class FileStorageUtilities {
+    /**
+     * Ensures that a folder exists in the given storage.
+     * @param storage Storage to create the folder in.
+     * @param folderPath Path to folder to ensure is created.
+     */
+    public static async ensureFolderExists(storage: FileStorage, folderPath: string): Promise<void> {
+        if (!await storage.pathExists(folderPath)) {
+            await storage.createFolder(folderPath);
+        }
+    }
+
+    /**
+     * Returns the file type of a file based on its extension.
+     * @remarks
+     * The file type is determined by the file extension. Only extensions found in the
+     * `FileExt[]` array are returned.
+     * @param filePath Path to file to get type for.
+     * @returns The file type, or undefined if the file type is unknown.
+     */
+    public static getFileType(filePath: string): FileType | undefined {
+        // Get extension from file
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext.length > 1) {
+            // Ensure the extension is valid
+            const fileType = ext.substring(1);
+            if (FileExt.includes(fileType)) {
+                return fileType as FileType;
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Maps a content type to a file type.
+     * @param contentType Content type to map.
+     * @returns File type, or undefined if the content type is unknown.
+     */
+    public static getFileTypeFromContentType(contentType: string): FileType | undefined {
+        if (Object.prototype.hasOwnProperty.call(ContentTypeMap, contentType)) {
+            return ContentTypeMap[contentType];
+        } else {
+            // Try to find a matching file type
+            const parts = contentType.split('/');
+            if (parts.length == 2) {
+                const fileType = parts[1].includes('+') ? parts[1].split('+')[0] : parts[1];
+                if (FileExt.includes(fileType)) {
+                    return fileType as FileType;
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Deletes a file from storage if it exists.
+     * @param storage Storage to delete the file from.
+     * @param filePath Path to the file to delete.
+     * @returns An Error if the file could not be deleted, otherwise undefined.
+     */
+    public static async tryDeleteFile(storage: FileStorage, filePath: string): Promise<Error | undefined> {
+        try {
+            await storage.deleteFile(filePath);
+            return undefined;
+        } catch (err: unknown) {
+            return err as Error;
+        }
+    }
+}

package/src/storage/FileType.ts

@@ -0,0 +1,61 @@
+export const ImageFileExt = ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'tif', 'webp', 'svg', 'heic', 'heif'];
+export type ImageFileType = typeof ImageFileExt[number];
+
+export const VideoFileExt = ['mp4', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'webm', 'mpg', 'mpeg', '3gp'];
+export type VideoFileType = typeof VideoFileExt[number];
+
+export const AudioFileExt = ['mp3', 'wav', 'flac', 'm4a', 'aac', 'ogg', 'wma', 'aiff', 'alac'];
+export type AudioFileType = typeof AudioFileExt[number];
+
+export const MediaFileExt = [...ImageFileExt, ...VideoFileExt, ...AudioFileExt];
+export type MediaFileType = ImageFileType | VideoFileType | AudioFileType;
+
+export const ModelFileExt = ['obj', 'fbx', 'stl', 'dae', 'ply', '3ds', 'gltf', 'glb'];
+export type ModelFileType = typeof ModelFileExt[number];
+
+export const ArchiveFileExt = ['zip', 'tar', 'gz', '7z', 'rar', 'tgz'];
+export type ArchiveFileType = typeof ArchiveFileExt[number];
+
+export const SystemFileExt = ['exe', 'dll', 'bin', 'iso', 'dmg', 'msi', 'deb', 'rpm', 'apk', 'appimage', 'rom', 'efi'];
+export type SystemFileType = typeof SystemFileExt[number];
+
+export const DatabaseFileExt = ['sqlite', 'sql', 'mdb', 'accdb'];
+export type DatabaseFileType = typeof DatabaseFileExt[number];
+
+export const BinaryFileExt = [...MediaFileExt, ...ModelFileExt, ...ArchiveFileExt, ...SystemFileExt, ...DatabaseFileExt];
+
+export const DocumentFileExt = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'rtf', 'tex'];
+export type DocumentFileType = typeof DocumentFileExt[number];
+
+export const TextDocumentFileExt = ['txt', 'csv', 'log', 'md', 'rst'];
+export type TextDocumentFileType = typeof TextDocumentFileExt[number];
+
+export const CodeFileExt = ['js', 'ts', 'jsx', 'tsx', 'py', 'java', 'c', 'cpp', 'cs', 'php', 'go', 'rb', 'rs', 'swift', 'kt', 'dart', 'sh', 'bash', 'ps1', 'bat', 'cmd', 'html', 'css', 'scss', 'sass', 'less', 'xml', 'json', 'yaml', 'yml', 'ini', 'conf', 'cfg', 'env'];
+export type CodeFileType = typeof CodeFileExt[number];
+
+export const PlainTextFileExt = [...TextDocumentFileExt, ...CodeFileExt];
+export type PlainTextFileType = TextDocumentFileType | CodeFileType;
+
+export const FileExt = [...BinaryFileExt, ...DocumentFileExt, ...PlainTextFileExt];
+export type FileType = typeof FileExt[number] | 'folder';
+
+export const ContentTypeMap: Record<string, FileType> = {
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/css": "css",
+    "text/javascript": "js",
+    "application/json": "json",
+    "application/xml": "xml",
+    "application/javascript": "js",
+    "application/pdf": "pdf",
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/svg+xml": "svg",
+    "application/zip": "zip",
+    "application/octet-stream": "bin",
+    "audio/mpeg": "mp3",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "text/csv": "csv",
+};