@peers-app/peers-sdk 0.7.0 → 0.7.3

package/dist/context/data-context.d.ts

@@ -10,8 +10,8 @@ export declare class DataContext {
     readonly tableContainer: TableContainer;
     readonly packageLoader: PackageLoader;
     readonly eventRegistry: EventRegistry;
+    readonly dataContextId: string;
     constructor(userContext: UserContext, groupId?: string | undefined);
-    get dataContextId(): string;
     /**
      * Call this to indicate that this should be the current data context to be used unless otherwise specified
      */

package/dist/context/data-context.js

@@ -10,9 +10,11 @@ class DataContext {
     tableContainer;
     packageLoader;
     eventRegistry;
+    dataContextId;
     constructor(userContext, groupId) {
         this.userContext = userContext;
         this.groupId = groupId;
+        this.dataContextId = groupId || userContext.userId;
         // Initialize dependencies in the correct order to avoid circular references
         this.eventRegistry = new orm_1.EventRegistry(this.dataContextId);
         this.packageLoader = new package_loader_1.PackageLoader(this);
@@ -23,9 +25,6 @@ class DataContext {
         const tableFactory = (metaData, schema, TableClass) => this.createTable(metaData, schema, TableClass);
         this.tableContainer = new orm_1.TableContainer(tableFactory, groupId);
     }
-    get dataContextId() {
-        return this.groupId || this.userContext.userId;
-    }
     /**
      * Call this to indicate that this should be the current data context to be used unless otherwise specified
      */

package/dist/context/user-context-singleton.js

@@ -86,38 +86,14 @@ if (!rpc_types_1.isClient) {
             .getTable(tableName);
         return table;
     }
-    // TODO: add check that client has permission to do the operation to the table
-    rpc_types_1.rpcServerCalls.tableGet = async (dataContextId, tableName, id) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.get(id);
-    };
-    rpc_types_1.rpcServerCalls.tableList = async (dataContextId, tableName, filter, opts) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.list(filter, opts);
-    };
-    rpc_types_1.rpcServerCalls.tableCount = async (dataContextId, tableName, filter) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.count(filter);
-    };
-    rpc_types_1.rpcServerCalls.tableSave = async (dataContextId, tableName, data, opts) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.save(data, opts);
-    };
-    rpc_types_1.rpcServerCalls.tableInsert = async (dataContextId, tableName, data) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.insert(data);
-    };
-    rpc_types_1.rpcServerCalls.tableUpdate = async (dataContextId, tableName, data) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.update(data);
-    };
-    rpc_types_1.rpcServerCalls.tableDelete = async (dataContextId, tableName, idOrRecord) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.delete(idOrRecord);
-    };
+    // TODO: add check that client has permission to make this call
     rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
         const table = await getTable(dataContextId, tableName);
-        // @ts-ignore
+        const method = table[methodName];
+        if (typeof method !== 'function') {
+            throw new Error(`Method ${methodName} not found on table ${tableName}`);
+        }
+        // @ts-ignore - call this way to ensure 'this' is correct
         return table[methodName](...args);
     };
 }

package/dist/context/user-context.d.ts

@@ -1,7 +1,6 @@
 import { DataContext } from "../context/data-context";
 import { IUser } from "../data";
 import type { DataSourceFactory, IDataChangedEvent, Table } from "../data/orm";
-import { TrustLevel } from "../device/socket.type";
 import { IPublicPrivateKeys } from "../keys";
 import { Observable } from "../observable";
 export declare class UserContext {
@@ -11,9 +10,6 @@ export declare class UserContext {
     readonly currentlyActiveGroupId: Observable<string | undefined>;
     readonly packagesRootDir: Observable<string>;
     readonly reloadPackagesOnPageRefresh: Observable<boolean>;
-    readonly packageLocalPathsResolved: Observable<{
-        [packageId: string]: string;
-    }>;
     readonly groupIds: Observable<string[]>;
     readonly userDataContext: DataContext;
     readonly groupDataContexts: Map<string, DataContext>;
@@ -37,10 +33,9 @@ export declare class UserContext {
     getMe(): Promise<{
         name: string;
         publicKey: string;
-        publicBoxKey: string;
         userId: string;
+        publicBoxKey: string;
         signature?: string | undefined;
-        trustLevel?: TrustLevel | undefined;
     } | undefined>;
     syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
     subscribeToDataChangedAcrossAllGroups<T extends {

package/dist/context/user-context.js

@@ -4,7 +4,6 @@ exports.UserContext = void 0;
 const lodash_1 = require("lodash");
 const data_context_1 = require("../context/data-context");
 const data_1 = require("../data");
-const socket_type_1 = require("../device/socket.type");
 const events_1 = require("../events");
 const keys_1 = require("../keys");
 const observable_1 = require("../observable");
@@ -16,7 +15,6 @@ class UserContext {
     currentlyActiveGroupId = (0, observable_1.observable)();
     packagesRootDir = (0, observable_1.observable)('');
     reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
-    packageLocalPathsResolved = (0, observable_1.observable)({});
     groupIds = (0, observable_1.observable)([]);
     userDataContext;
     groupDataContexts = new Map();
@@ -109,7 +107,7 @@ class UserContext {
      */
     async loadUserContextObservablesFromDB() {
         const persistentVars = await this.userDataContext.tableContainer.getTableByName(data_1.persistentVarsMetaData.name);
-        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh', 'packageLocalPathsResolved'] } });
+        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh'] } });
         const varDbValues = vars.reduce((acc, curr) => {
             acc[curr.name] = curr.value?.value;
             return acc;
@@ -127,14 +125,10 @@ class UserContext {
         const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: false, dbValue: varDbValues['reloadPackagesOnPageRefresh'], userContext: this });
         this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
         (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
-        const packageLocalPathsResolvedPVar = (0, data_1.deviceVar)('packageLocalPathsResolved', { defaultValue: {}, dbValue: varDbValues['packageLocalPathsResolved'], userContext: this });
-        this.packageLocalPathsResolved(packageLocalPathsResolvedPVar());
-        (0, observable_1.linkObservables)(packageLocalPathsResolvedPVar, this.packageLocalPathsResolved);
         await Promise.all([
             deviceIdPVar.loadingPromise,
             packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
-            packageLocalPathsResolvedPVar.loadingPromise,
         ]);
     }
     async getMe() {
@@ -153,7 +147,6 @@ class UserContext {
                 name: 'Unnamed_1',
                 publicKey: '',
                 publicBoxKey: '',
-                trustLevel: socket_type_1.TrustLevel.Self,
             };
         }
         me.publicKey = keys.publicKey;
@@ -167,9 +160,8 @@ class UserContext {
         // sync my user to all all my groups
         for (const [, dataContext] of userContext.groupDataContexts) {
             let groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
-            if (!groupMe || groupMe.name !== me.name || groupMe.publicKey !== me.publicKey) {
-                groupMe = (0, keys_1.addSignatureToObject)({ ...me, trustLevel: groupMe?.trustLevel || socket_type_1.TrustLevel.NewUser }, keys.secretKey);
-                await (0, data_1.Users)(dataContext).save(groupMe);
+            if (!(0, lodash_1.isEqual)(groupMe, meSigned)) {
+                await (0, data_1.Users)(dataContext).save(meSigned);
             }
         }
         // sync group objects to my personal db
@@ -181,7 +173,13 @@ class UserContext {
             const groupObject = await (0, data_1.Groups)(dataContext).get(dataContext.groupId);
             const myGroupObject = await (0, data_1.Groups)(this.userDataContext).get(dataContext.groupId);
             if (groupObject && !(0, lodash_1.isEqual)(groupObject, myGroupObject)) {
-                (0, keys_1.verifyObjectSignature)(groupObject);
+                try {
+                    (0, keys_1.verifyObjectSignature)(groupObject);
+                }
+                catch (err) {
+                    console.error(`Error verifying group object from group ${dataContext.groupId}:`, err);
+                    continue;
+                }
                 await (0, data_1.Groups)(this.userDataContext).save(groupObject);
             }
         }

package/dist/data/assistants.d.ts

@@ -39,7 +39,7 @@ export declare const assistantSchema: z.ZodObject<{
     toolInclusionStrategy?: ToolInclusionStrategy | undefined;
 }>;
 export type IAssistant = z.infer<typeof assistantSchema>;
-export declare function Assistants(dataContext?: DataContext): import("..").Table<{
+export declare function Assistants(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     createdAt: Date;
     assistantId: string;

package/dist/data/change-tracking.d.ts

@@ -10,22 +10,22 @@ declare const insertChange: z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -40,20 +40,20 @@ declare const deleteChange: z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 export type IChangeDelete = z.infer<typeof deleteChange>;
@@ -67,23 +67,23 @@ declare const updateChange: z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -99,22 +99,22 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -127,20 +127,20 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>, z.ZodObject<{
     changeId: z.ZodEffects<z.ZodString, string, string>;
@@ -152,23 +152,23 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -186,25 +186,25 @@ export declare const changeTrackingSchema: z.ZodObject<{
     newRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
     jsonDiff: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
 }>;
 export type IChangeAny = z.infer<typeof changeTrackingSchema>;
 export declare class ChangeTrackingTable extends SQLDataSource<IChange> {

package/dist/data/channels.d.ts

@@ -20,7 +20,7 @@ export declare const channelSchema: z.ZodObject<{
     owningGroupId: string;
 }>;
 export type IChannel = z.infer<typeof channelSchema>;
-export declare function Channels(dataContext?: DataContext): import("..").Table<{
+export declare function Channels(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     description: string;
     createdAt: Date;

package/dist/data/data-locks.d.ts

@@ -7,13 +7,13 @@ export declare const dataLockSchema: z.ZodObject<{
     lockedUntil: z.ZodNumber;
     acknowledged: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    dataLockId: string;
     recordId: string;
+    dataLockId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }, {
-    dataLockId: string;
     recordId: string;
+    dataLockId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }>;

package/dist/data/devices.d.ts

@@ -11,18 +11,18 @@ export declare const deviceSchema: z.ZodObject<{
     trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
 }, "strip", z.ZodTypeAny, {
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }, {
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }>;
@@ -38,12 +38,12 @@ export interface IDeviceHandshake extends IDeviceInfo {
     serverAddress: string;
     timestamp: number;
 }
-export declare function Devices(dataContext?: DataContext): import("..").Table<{
+export declare function Devices(dataContext?: DataContext): import("./orm").Table<{
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }>;

package/dist/data/embeddings.d.ts

@@ -34,7 +34,7 @@ export declare const embeddingSchema: z.ZodObject<{
     embeddingType: string;
 }>;
 export type IEmbedding = z.infer<typeof embeddingSchema>;
-export declare function Embeddings(dataContext?: DataContext): import("..").Table<{
+export declare function Embeddings(dataContext?: DataContext): import("./orm").Table<{
     metadata: {
         fkId?: string | undefined;
     } & {

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

@@ -4,23 +4,25 @@ 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() */
+    /** @deprecated Direct inserts forbidden; use saveFile() or saveFileRecord() */
     insert(..._args: Parameters<Table<any>['insert']>): never;
-    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct updates forbidden; use saveFile() or saveFileRecord() */
     update(..._args: Parameters<Table<any>['update']>): never;
     /** @deprecated Direct deletes forbidden; use deleteFile() */
     delete(..._args: Parameters<Table<any>['delete']>): never;
+    /** @deprecated Direct save forbidden; use saveFile() or saveFileRecord() */
+    save(..._args: Parameters<Table<any>['save']>): 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
+     * Note: Use `saveFile` to write a file to disk. This method is for managing
+     * the file metadata in the database which is done automatically by `saveFile`.
+     * @param fileRecord The file record to save to the database
      * @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>;
+    getFileContents(fileId: string): Promise<Uint8Array | null>;
     deleteFile(fileId: string): Promise<void>;
     createIndexFileRecursively(chunkHashes: string[]): Promise<string>;
     loadChunkHashesRecursively(indexFileId: string): Promise<string[]>;

package/dist/data/files/files.js

@@ -11,25 +11,29 @@ 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() */
+    /** @deprecated Direct inserts forbidden; use saveFile() or saveFileRecord() */
     insert(..._args) {
-        throw new Error('Direct inserts forbidden; use safeFile() or saveFileRecord()');
+        throw new Error('Direct inserts forbidden; use saveFile() or saveFileRecord()');
     }
-    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct updates forbidden; use saveFile() or saveFileRecord() */
     update(..._args) {
-        throw new Error('Direct updates forbidden; use safeFile() or saveFileRecord()');
+        throw new Error('Direct updates forbidden; use saveFile() or saveFileRecord()');
     }
     /** @deprecated Direct deletes forbidden; use deleteFile() */
     delete(..._args) {
         throw new Error('Direct deletes forbidden; use deleteFile()');
     }
+    /** @deprecated Direct save forbidden; use saveFile() or saveFileRecord() */
+    save(..._args) {
+        throw new Error('Direct saves forbidden; use saveFile() or saveFileRecord()');
+    }
     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
+     * Note: Use `saveFile` to write a file to disk. This method is for managing
+     * the file metadata in the database which is done automatically by `saveFile`.
+     * @param fileRecord The file record to save to the database
      * @returns The inserted file record
      */
     async saveFileRecord(fileRecord) {
@@ -56,7 +60,7 @@ class FilesTable extends orm_1.Table {
         // Finalize and return the result
         return await writeStream.finalize();
     }
-    async getFile(fileId) {
+    async getFileContents(fileId) {
         // Use FileReadStream internally to ensure consistent chunk reading logic
         const readStream = await this.openReadStream(fileId);
         if (!readStream) {
@@ -76,9 +80,9 @@ class FilesTable extends orm_1.Table {
             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
+        // TODO Chunk cleanup needs to be implemented as a separate garbage collection process
         // that removes chunks not referenced by any files
-        // Delete from database
+        // Delete file record from database
         await super.delete(fileId);
     }
     // Create an index file recursively for large files
@@ -103,7 +107,7 @@ class FilesTable extends orm_1.Table {
     // Load chunk hashes recursively from an index file
     async loadChunkHashesRecursively(indexFileId) {
         // Recursively load the index file
-        const indexBuffer = await this.getFile(indexFileId);
+        const indexBuffer = await this.getFileContents(indexFileId);
         if (!indexBuffer) {
             throw new Error(`Index file not found: ${indexFileId}`);
         }
@@ -119,7 +123,7 @@ function Files(dataContext) {
 }
 // TODO implement permissions check for file access
 rpc_types_1.rpcServerCalls.getFileContents = async (fileId, encoding = 'utf8') => {
-    const data = await Files().getFile(fileId);
+    const data = await Files().getFileContents(fileId);
     if (data === null) {
         throw new Error(`File not found: ${fileId}`);
     }