@peers-app/peers-sdk 0.1.4

package/dist/data/files/file-read-stream.d.ts

@@ -0,0 +1,27 @@
+import { IFile } from './file.types';
+import type { FilesTable } from './files';
+export declare class FileReadStream {
+    private fileRecord;
+    private fileTable;
+    private preloadChunksCount;
+    private chunkHashes;
+    private currentChunkIndex;
+    private currentChunkBuffer;
+    private chunkPromises;
+    private positionInChunk;
+    private totalPosition;
+    private eof;
+    constructor(fileRecord: IFile, fileTable: FilesTable, preloadChunksCount?: number);
+    private loadChunkHashes;
+    private loadChunkByIndex;
+    private preloadChunks;
+    private loadCurrentChunk;
+    read(size?: number): Promise<Uint8Array | null>;
+    seek(position: number): Promise<void>;
+    getMetadata(): IFile;
+    getPosition(): number;
+    getFileSize(): number;
+    isEOF(): boolean;
+    getBytesRemaining(): number;
+    readAll(): Promise<Uint8Array | null>;
+}

package/dist/data/files/file-read-stream.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReadStream = void 0;
+const keys_1 = require("../../keys");
+const file_types_1 = require("./file.types");
+class FileReadStream {
+    fileRecord;
+    fileTable;
+    preloadChunksCount;
+    chunkHashes = null;
+    currentChunkIndex = 0;
+    currentChunkBuffer = null;
+    chunkPromises = new Map();
+    positionInChunk = 0;
+    totalPosition = 0;
+    eof = false;
+    constructor(fileRecord, fileTable, preloadChunksCount = 2) {
+        this.fileRecord = fileRecord;
+        this.fileTable = fileTable;
+        this.preloadChunksCount = preloadChunksCount;
+    }
+    async loadChunkHashes() {
+        if (this.chunkHashes !== null) {
+            return; // Already loaded
+        }
+        if (this.fileRecord.chunkHashes) {
+            // Small file: chunk hashes stored directly in database
+            this.chunkHashes = this.fileRecord.chunkHashes;
+        }
+        else if (this.fileRecord.indexFileId) {
+            // Large file: chunk hashes stored in separate index file (recursively)
+            this.chunkHashes = await this.fileTable.loadChunkHashesRecursively(this.fileRecord.indexFileId);
+        }
+        else {
+            throw new Error(`File ${this.fileRecord.fileId} has neither chunkHashes nor indexFileId`);
+        }
+    }
+    async loadChunkByIndex(chunkIndex) {
+        await this.loadChunkHashes();
+        if (chunkIndex >= this.chunkHashes.length) {
+            throw new Error(`Chunk index ${chunkIndex} out of bounds`);
+        }
+        const chunkHash = this.chunkHashes[chunkIndex];
+        const ops = await (0, file_types_1.getFileOps)();
+        const chunkPath = `${file_types_1.CHUNKS_DIR}/${chunkHash}`;
+        let chunk;
+        if (await ops.fileExists(chunkPath)) {
+            // Read from local storage
+            chunk = await ops.readFile(chunkPath);
+        }
+        else {
+            // Download from peer by hash
+            chunk = (await ops.downloadFileChunk(chunkHash));
+            if (!chunk) {
+                throw new Error(`Chunk ${chunkHash} not found in storage or peers`);
+            }
+        }
+        // Verify chunk integrity
+        const actualChunkHash = (0, keys_1.hashBytes)(chunk);
+        if (actualChunkHash !== chunkHash) {
+            throw new Error(`Chunk integrity check failed: expected ${chunkHash}, got ${actualChunkHash}`);
+        }
+        return chunk;
+    }
+    async preloadChunks() {
+        await this.loadChunkHashes();
+        // Start from current chunk and preload up to preloadChunksCount ahead
+        for (let offset = 0; offset < this.preloadChunksCount; offset++) {
+            const chunkIndex = this.currentChunkIndex + offset;
+            if (chunkIndex >= this.chunkHashes.length) {
+                break; // No more chunks to preload
+            }
+            if (!this.chunkPromises.has(chunkIndex)) {
+                // Start preload but don't await it - let it happen in background
+                // Add error handling to prevent unhandled promise rejections
+                const safeChunkPromise = this.loadChunkByIndex(chunkIndex).catch(error => {
+                    // Re-throw so error is available when promise is consumed
+                    throw error;
+                });
+                // Add no-op catch to prevent unhandled promise rejection warnings
+                safeChunkPromise.catch(() => { });
+                this.chunkPromises.set(chunkIndex, safeChunkPromise);
+            }
+        }
+    }
+    async loadCurrentChunk() {
+        await this.preloadChunks();
+        if (this.currentChunkIndex >= this.chunkHashes.length) {
+            this.eof = true;
+            this.currentChunkBuffer = null;
+            this.chunkPromises.clear();
+            return;
+        }
+        const chunkPromise = this.chunkPromises.get(this.currentChunkIndex);
+        this.currentChunkBuffer = await chunkPromise;
+        this.chunkPromises.delete(this.currentChunkIndex);
+    }
+    async read(size) {
+        if (this.eof) {
+            return null;
+        }
+        // Default to reading one full chunk if no size specified
+        if (size === undefined) {
+            size = file_types_1.FILE_CHUNK_SIZE;
+        }
+        const chunks = [];
+        let remainingBytes = size;
+        while (remainingBytes > 0 && !this.eof) {
+            // Load current chunk if needed
+            if (!this.currentChunkBuffer) {
+                await this.loadCurrentChunk();
+                if (this.eof) {
+                    break;
+                }
+            }
+            // Read from current chunk
+            const availableInChunk = this.currentChunkBuffer.length - this.positionInChunk;
+            const bytesToRead = Math.min(remainingBytes, availableInChunk);
+            const chunkPortion = this.currentChunkBuffer.subarray(this.positionInChunk, this.positionInChunk + bytesToRead);
+            chunks.push(chunkPortion);
+            remainingBytes -= bytesToRead;
+            this.positionInChunk += bytesToRead;
+            this.totalPosition += bytesToRead;
+            // If we've consumed the entire chunk, move to next one
+            if (this.positionInChunk >= this.currentChunkBuffer.length) {
+                this.currentChunkIndex++;
+                this.currentChunkBuffer = null;
+                this.positionInChunk = 0;
+            }
+        }
+        await this.preloadChunks();
+        return chunks.length > 0 ? new Uint8Array(Buffer.concat(chunks)) : null;
+    }
+    async seek(position) {
+        if (position < 0) {
+            throw new Error('Seek position cannot be negative');
+        }
+        if (position > this.fileRecord.fileSize) {
+            throw new Error('Seek position beyond file size');
+        }
+        await this.loadChunkHashes();
+        // Calculate which chunk contains the target position
+        const targetChunkIndex = Math.floor(position / file_types_1.FILE_CHUNK_SIZE);
+        const positionInTargetChunk = position % file_types_1.FILE_CHUNK_SIZE;
+        this.currentChunkIndex = targetChunkIndex;
+        this.positionInChunk = positionInTargetChunk;
+        this.totalPosition = position;
+        this.currentChunkBuffer = null; // Will be loaded on next read
+        // Only set EOF if we're seeking beyond the last chunk OR at the very end of the file
+        this.eof = (targetChunkIndex >= this.chunkHashes.length) || (position >= this.fileRecord.fileSize);
+        this.chunkPromises.clear();
+        await this.preloadChunks();
+    }
+    getMetadata() {
+        return { ...this.fileRecord };
+    }
+    getPosition() {
+        return this.totalPosition;
+    }
+    getFileSize() {
+        return this.fileRecord.fileSize;
+    }
+    isEOF() {
+        return this.eof;
+    }
+    getBytesRemaining() {
+        return this.fileRecord.fileSize - this.totalPosition;
+    }
+    // Read the entire file (for compatibility with existing getFile API)
+    async readAll() {
+        await this.seek(0); // Start from beginning
+        const chunks = [];
+        let chunk;
+        try {
+            while ((chunk = await this.read()) !== null) {
+                chunks.push(chunk);
+            }
+            return new Uint8Array(Buffer.concat(chunks));
+        }
+        catch (error) {
+            // Only return null for chunk-specific errors (not found, download failed)
+            // Rethrow other errors like index file issues
+            if (error instanceof Error &&
+                (error.message.includes('Chunk') &&
+                    (error.message.includes('not found') || error.message.includes('integrity check failed')))) {
+                return null;
+            }
+            throw error;
+        }
+        finally {
+            this.chunkPromises.clear();
+        }
+    }
+}
+exports.FileReadStream = FileReadStream;

package/dist/data/files/file-write-stream.d.ts

@@ -0,0 +1,20 @@
+import { IFile, IFileInput } from './file.types';
+import type { FilesTable } from './files';
+export declare class FileWriteStream {
+    private metadata;
+    private fileTable;
+    private buffer;
+    private chunkHashes;
+    private bytesWritten;
+    private finalized;
+    private aborted;
+    constructor(metadata: IFileInput, fileTable: FilesTable);
+    write(chunk: Uint8Array): Promise<void>;
+    private processCompleteChunks;
+    finalize(): Promise<IFile>;
+    abort(): Promise<void>;
+    getBytesWritten(): number;
+    getChunkCount(): number;
+    isFinalized(): boolean;
+    isAborted(): boolean;
+}

package/dist/data/files/file-write-stream.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWriteStream = void 0;
+const keys_1 = require("../../keys");
+const file_types_1 = require("./file.types");
+class FileWriteStream {
+    metadata;
+    fileTable;
+    buffer = new Uint8Array(0);
+    chunkHashes = [];
+    bytesWritten = 0;
+    finalized = false;
+    aborted = false;
+    constructor(metadata, fileTable) {
+        this.metadata = metadata;
+        this.fileTable = fileTable;
+    }
+    async write(chunk) {
+        if (this.finalized) {
+            throw new Error('Cannot write to finalized stream');
+        }
+        if (this.aborted) {
+            throw new Error('Cannot write to aborted stream');
+        }
+        // Add chunk to buffer
+        this.buffer = new Uint8Array(Buffer.concat([this.buffer, chunk]));
+        this.bytesWritten += chunk.length;
+        // Process complete chunks
+        await this.processCompleteChunks();
+    }
+    async processCompleteChunks() {
+        const ops = await (0, file_types_1.getFileOps)();
+        while (this.buffer.length >= file_types_1.FILE_CHUNK_SIZE) {
+            // Extract one chunk
+            const chunkData = this.buffer.subarray(0, file_types_1.FILE_CHUNK_SIZE);
+            this.buffer = this.buffer.subarray(file_types_1.FILE_CHUNK_SIZE);
+            // Hash and store the chunk
+            const chunkHash = (0, keys_1.hashBytes)(chunkData);
+            this.chunkHashes.push(chunkHash);
+            const chunkPath = `${file_types_1.CHUNKS_DIR}/${chunkHash}`;
+            await ops.writeFile(chunkPath, chunkData);
+        }
+    }
+    async finalize() {
+        if (this.finalized) {
+            throw new Error('Stream already finalized');
+        }
+        if (this.aborted) {
+            throw new Error('Cannot finalize aborted stream');
+        }
+        // First, process any complete chunks in the buffer
+        await this.processCompleteChunks();
+        // Then process any remaining partial data as final chunk
+        if (this.buffer.length > 0) {
+            const ops = await (0, file_types_1.getFileOps)();
+            const finalChunkHash = (0, keys_1.hashBytes)(this.buffer);
+            this.chunkHashes.push(finalChunkHash);
+            const chunkPath = `${file_types_1.CHUNKS_DIR}/${finalChunkHash}`;
+            await ops.writeFile(chunkPath, this.buffer);
+            this.buffer = new Uint8Array(0);
+        }
+        // Create the file record using the same logic as FileTable.saveFile
+        const chunkHashesString = JSON.stringify(this.chunkHashes);
+        const fileHash = (0, keys_1.hashBytes)(Buffer.from(chunkHashesString, 'utf8'));
+        let fileRecord;
+        if (this.chunkHashes.length > file_types_1.CHUNK_INDEX_THRESHOLD) {
+            // Large file: use recursive index file
+            const indexFileId = await this.fileTable.createIndexFileRecursively(this.chunkHashes);
+            fileRecord = {
+                ...this.metadata,
+                fileSize: this.bytesWritten,
+                fileHash,
+                indexFileId
+            };
+        }
+        else {
+            // Small file: store chunk hashes directly
+            fileRecord = {
+                ...this.metadata,
+                fileSize: this.bytesWritten,
+                fileHash,
+                chunkHashes: this.chunkHashes
+            };
+        }
+        // Save to database
+        await this.fileTable.saveFileRecord(fileRecord);
+        this.finalized = true;
+        return fileRecord;
+    }
+    async abort() {
+        if (this.finalized) {
+            throw new Error('Cannot abort finalized stream');
+        }
+        this.aborted = true;
+        this.buffer = Buffer.alloc(0);
+        this.chunkHashes = [];
+        // Note: We don't delete chunks since they may be shared with other files
+        // Chunk cleanup should be handled by a separate garbage collection process
+    }
+    getBytesWritten() {
+        return this.bytesWritten;
+    }
+    getChunkCount() {
+        return this.chunkHashes.length;
+    }
+    isFinalized() {
+        return this.finalized;
+    }
+    isAborted() {
+        return this.aborted;
+    }
+}
+exports.FileWriteStream = FileWriteStream;

package/dist/data/files/file.types.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { ITableMetaData } from "../orm/types";
+export declare const fileSchema: z.ZodObject<{
+    fileId: z.ZodString;
+    name: z.ZodString;
+    fileSize: z.ZodNumber;
+    fileHash: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+    chunkHashes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isIndexFile: z.ZodOptional<z.ZodBoolean>;
+    indexFileId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    fileId: string;
+    fileSize: number;
+    fileHash: string;
+    mimeType?: string | undefined;
+    chunkHashes?: string[] | undefined;
+    isIndexFile?: boolean | undefined;
+    indexFileId?: string | undefined;
+}, {
+    name: string;
+    fileId: string;
+    fileSize: number;
+    fileHash: string;
+    mimeType?: string | undefined;
+    chunkHashes?: string[] | undefined;
+    isIndexFile?: boolean | undefined;
+    indexFileId?: string | undefined;
+}>;
+export type IFile = z.infer<typeof fileSchema>;
+export type IFileInput = Pick<IFile, 'fileId' | 'name' | 'fileSize' | 'mimeType' | 'isIndexFile'>;
+export declare const filesMetaData: ITableMetaData;
+export declare const FILE_CHUNK_SIZE: number;
+export declare const CHUNKS_DIR = "file_chunks";
+export declare let CHUNK_INDEX_THRESHOLD: number;
+export declare function setChunkIndexThreshold(threshold: number): void;
+export interface FileOps {
+    downloadFileChunk(chunkHash: string): Promise<Uint8Array | null>;
+    fileExists(path: string): Promise<boolean>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    deletePath(path: string): Promise<void>;
+}
+export declare function setFileOps(ops: FileOps): void;
+export declare function getFileOps(): Promise<FileOps>;
+export declare function resetFileOps(): void;

package/dist/data/files/file.types.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHUNK_INDEX_THRESHOLD = exports.CHUNKS_DIR = exports.FILE_CHUNK_SIZE = exports.filesMetaData = exports.fileSchema = void 0;
+exports.setChunkIndexThreshold = setChunkIndexThreshold;
+exports.setFileOps = setFileOps;
+exports.getFileOps = getFileOps;
+exports.resetFileOps = resetFileOps;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+exports.fileSchema = zod_1.z.object({
+    fileId: zod_1.z.string(),
+    name: zod_1.z.string().describe('The name of the file'),
+    fileSize: zod_1.z.number().describe('The size of the file in bytes'),
+    fileHash: zod_1.z.string().describe('Hash of the chunk hashes array for integrity verification'),
+    mimeType: zod_1.z.string().optional().describe('The MIME type of the file'),
+    chunkHashes: zod_1.z.array(zod_1.z.string()).optional().describe('SHA-256 hashes of each chunk in order (for small files)'),
+    isIndexFile: zod_1.z.boolean().optional().describe('True if this is an index file for another large file'),
+    indexFileId: zod_1.z.string().optional().describe('FileId of index file (for large files)'),
+});
+exports.filesMetaData = {
+    name: 'Files',
+    description: 'Files stored in the chunked file system for peer sharing',
+    primaryKeyName: 'fileId',
+    fields: (0, types_1.schemaToFields)(exports.fileSchema),
+};
+// File storage configuration
+exports.FILE_CHUNK_SIZE = 1024 * 1024; // 1MB chunks
+exports.CHUNKS_DIR = 'file_chunks';
+exports.CHUNK_INDEX_THRESHOLD = 1000; // Use chunk index file for files with >1000 chunks (~1GB)
+// For testing - allow modifying the threshold
+function setChunkIndexThreshold(threshold) {
+    exports.CHUNK_INDEX_THRESHOLD = threshold;
+}
+let fileOps = null;
+let fileOpsReady = null;
+function setFileOps(ops) {
+    fileOps = ops;
+    if (fileOpsReady) {
+        fileOpsReady(ops);
+        fileOpsReady = null; // Reset the promise if it was waiting
+    }
+}
+function getFileOps() {
+    if (fileOps) {
+        return Promise.resolve(fileOps);
+    }
+    return new Promise((resolve) => {
+        fileOpsReady = resolve;
+    });
+}
+// For testing - reset the global state
+function resetFileOps() {
+    fileOps = null;
+    fileOpsReady = null;
+}

package/dist/data/files/files.d.ts

@@ -0,0 +1,28 @@
+import { Table } from "../orm";
+import { FileReadStream } from "./file-read-stream";
+import { FileWriteStream } from "./file-write-stream";
+import { IFile, IFileInput } from "./file.types";
+import type { DataContext } from "../../context/data-context";
+export declare class FilesTable extends Table<IFile> {
+    /** @deprecated Direct inserts forbidden; use safeFile() or saveFileRecord() */
+    insert(..._args: Parameters<Table<any>['insert']>): never;
+    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    update(..._args: Parameters<Table<any>['update']>): never;
+    /** @deprecated Direct deletes forbidden; use deleteFile() */
+    delete(..._args: Parameters<Table<any>['delete']>): never;
+    createWriteStream(metadata: IFileInput): Promise<FileWriteStream>;
+    /**
+     * Note: Use `saveFile` instead for direct use. This method is intended for internal use
+     * to insert a file record into the database as part of streaming operations.
+     * @param fileRecord The file record to insert
+     * @returns The inserted file record
+     */
+    saveFileRecord(fileRecord: IFile): Promise<IFile>;
+    openReadStream(fileId: string, preloadChunksCount?: number): Promise<FileReadStream | null>;
+    saveFile(metaData: IFileInput, data: Uint8Array | string): Promise<IFile>;
+    getFile(fileId: string): Promise<Uint8Array | null>;
+    deleteFile(fileId: string): Promise<void>;
+    createIndexFileRecursively(chunkHashes: string[]): Promise<string>;
+    loadChunkHashesRecursively(indexFileId: string): Promise<string[]>;
+}
+export declare function Files(dataContext?: DataContext): FilesTable;

package/dist/data/files/files.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesTable = void 0;
+exports.Files = Files;
+const rpc_types_1 = require("../../rpc-types");
+const utils_1 = require("../../utils");
+const orm_1 = require("../orm");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const file_read_stream_1 = require("./file-read-stream");
+const file_write_stream_1 = require("./file-write-stream");
+const file_types_1 = require("./file.types");
+class FilesTable extends orm_1.Table {
+    /** @deprecated Direct inserts forbidden; use safeFile() or saveFileRecord() */
+    insert(..._args) {
+        throw new Error('Direct inserts forbidden; use safeFile() or saveFileRecord()');
+    }
+    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    update(..._args) {
+        throw new Error('Direct updates forbidden; use safeFile() or saveFileRecord()');
+    }
+    /** @deprecated Direct deletes forbidden; use deleteFile() */
+    delete(..._args) {
+        throw new Error('Direct deletes forbidden; use deleteFile()');
+    }
+    async createWriteStream(metadata) {
+        return new file_write_stream_1.FileWriteStream(metadata, this);
+    }
+    /**
+     * Note: Use `saveFile` instead for direct use. This method is intended for internal use
+     * to insert a file record into the database as part of streaming operations.
+     * @param fileRecord The file record to insert
+     * @returns The inserted file record
+     */
+    async saveFileRecord(fileRecord) {
+        return await super.save(fileRecord);
+    }
+    async openReadStream(fileId, preloadChunksCount) {
+        const fileRecord = await this.get(fileId);
+        if (!fileRecord) {
+            return null;
+        }
+        return new file_read_stream_1.FileReadStream(fileRecord, this, preloadChunksCount);
+    }
+    async saveFile(metaData, data) {
+        // Use FileWriteStream internally to ensure consistent chunking logic
+        const writeStream = await this.createWriteStream({
+            ...metaData,
+            fileSize: data.length // Set the actual file size
+        });
+        // Write the entire data to the stream
+        if (typeof data === 'string') {
+            data = new Uint8Array(Buffer.from(data, 'utf8'));
+        }
+        await writeStream.write(data);
+        // Finalize and return the result
+        return await writeStream.finalize();
+    }
+    async getFile(fileId) {
+        // Use FileReadStream internally to ensure consistent chunk reading logic
+        const readStream = await this.openReadStream(fileId);
+        if (!readStream) {
+            return null;
+        }
+        // Read the entire file using the streaming implementation
+        return await readStream.readAll();
+    }
+    async deleteFile(fileId) {
+        // Get file metadata from database
+        const fileRecord = await super.get(fileId);
+        if (!fileRecord) {
+            return; // File doesn't exist
+        }
+        // If this file has an index file, recursively delete it first
+        if (fileRecord.indexFileId) {
+            await this.deleteFile(fileRecord.indexFileId);
+        }
+        // Note: We don't delete chunks since they may be shared with other files
+        // Chunk cleanup could be implemented as a separate garbage collection process
+        // that removes chunks not referenced by any files
+        // Delete from database
+        await super.delete(fileId);
+    }
+    // Create an index file recursively for large files
+    async createIndexFileRecursively(chunkHashes) {
+        // Create JSON content with chunk hashes
+        const indexContent = JSON.stringify(chunkHashes);
+        const indexBuffer = Buffer.from(indexContent, 'utf8');
+        // Generate a new file ID for the index file
+        const indexFileId = (0, utils_1.newid)();
+        // Create metadata for the index file
+        const indexMetadata = {
+            fileId: indexFileId,
+            name: `index-${indexFileId}.json`,
+            fileSize: indexBuffer.length,
+            mimeType: 'application/json',
+            isIndexFile: true
+        };
+        // Recursively save the index file (this will chunk it if it's too large)
+        await this.saveFile(indexMetadata, indexBuffer);
+        return indexFileId;
+    }
+    // Load chunk hashes recursively from an index file
+    async loadChunkHashesRecursively(indexFileId) {
+        // Recursively load the index file
+        const indexBuffer = await this.getFile(indexFileId);
+        if (!indexBuffer) {
+            throw new Error(`Index file not found: ${indexFileId}`);
+        }
+        // Parse chunk hashes from JSON
+        const indexContent = Buffer.from(indexBuffer).toString('utf8');
+        return JSON.parse(indexContent);
+    }
+}
+exports.FilesTable = FilesTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(file_types_1.filesMetaData, file_types_1.fileSchema, FilesTable);
+function Files(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(file_types_1.filesMetaData, file_types_1.fileSchema);
+}
+// TODO implement permissions check for file access
+rpc_types_1.rpcServerCalls.getFileContents = async (fileId, encoding = 'utf8') => {
+    const data = await Files().getFile(fileId);
+    if (data === null) {
+        throw new Error(`File not found: ${fileId}`);
+    }
+    return Buffer.from(data).toString(encoding);
+};

package/dist/data/files/files.test.d.ts

@@ -0,0 +1 @@
+export {};