@memberjunction/server 3.1.0 → 3.2.0

package/dist/resolvers/FileResolver.js

@@ -10,9 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { EntityPermissionType, Metadata, FieldValueCollection } from '@memberjunction/core';
-import { Arg, Ctx, DeleteOptionsInput, Field, FieldResolver, InputType, Mutation, ObjectType, PubSub, PubSubEngine, Resolver, Root, } from '@memberjunction/server';
-import { createDownloadUrl, createUploadUrl, deleteObject, moveObject } from '@memberjunction/storage';
+import { EntityPermissionType, Metadata, FieldValueCollection, RunView } from '@memberjunction/core';
+import { Arg, Ctx, DeleteOptionsInput, Field, FieldResolver, InputType, Int, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver, Root, } from '@memberjunction/server';
+import { createDownloadUrl, createUploadUrl, deleteObject, moveObject, copyObject, listObjects, copyObjectBetweenProviders, searchAcrossAccounts, initializeDriverWithAccountCredentials, } from '@memberjunction/storage';
 import { CreateMJFileInput, MJFileResolver as FileResolverBase, MJFile_, UpdateMJFileInput } from '../generated/generated.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
 import { GetReadOnlyProvider } from '../util.js';
@@ -59,7 +59,470 @@ FileExt = __decorate([
     ObjectType()
 ], FileExt);
 export { FileExt };
+let StorageObjectMetadata = class StorageObjectMetadata {
+    name;
+    path;
+    fullPath;
+    size;
+    contentType;
+    lastModified;
+    isDirectory;
+    etag;
+    cacheControl;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "name", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "path", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "fullPath", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], StorageObjectMetadata.prototype, "size", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "contentType", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "lastModified", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], StorageObjectMetadata.prototype, "isDirectory", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "etag", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], StorageObjectMetadata.prototype, "cacheControl", void 0);
+StorageObjectMetadata = __decorate([
+    ObjectType()
+], StorageObjectMetadata);
+export { StorageObjectMetadata };
+let StorageListResult = class StorageListResult {
+    objects;
+    prefixes;
+};
+__decorate([
+    Field(() => [StorageObjectMetadata]),
+    __metadata("design:type", Array)
+], StorageListResult.prototype, "objects", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], StorageListResult.prototype, "prefixes", void 0);
+StorageListResult = __decorate([
+    ObjectType()
+], StorageListResult);
+export { StorageListResult };
+let ListStorageObjectsInput = class ListStorageObjectsInput {
+    AccountID;
+    Prefix;
+    Delimiter;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListStorageObjectsInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListStorageObjectsInput.prototype, "Prefix", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ListStorageObjectsInput.prototype, "Delimiter", void 0);
+ListStorageObjectsInput = __decorate([
+    InputType()
+], ListStorageObjectsInput);
+export { ListStorageObjectsInput };
+let CreatePreAuthDownloadUrlInput = class CreatePreAuthDownloadUrlInput {
+    AccountID;
+    ObjectName;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreatePreAuthDownloadUrlInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreatePreAuthDownloadUrlInput.prototype, "ObjectName", void 0);
+CreatePreAuthDownloadUrlInput = __decorate([
+    InputType()
+], CreatePreAuthDownloadUrlInput);
+export { CreatePreAuthDownloadUrlInput };
+let CreatePreAuthUploadUrlInput = class CreatePreAuthUploadUrlInput {
+    AccountID;
+    ObjectName;
+    ContentType;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreatePreAuthUploadUrlInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreatePreAuthUploadUrlInput.prototype, "ObjectName", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CreatePreAuthUploadUrlInput.prototype, "ContentType", void 0);
+CreatePreAuthUploadUrlInput = __decorate([
+    InputType()
+], CreatePreAuthUploadUrlInput);
+export { CreatePreAuthUploadUrlInput };
+let CreatePreAuthUploadUrlPayload = class CreatePreAuthUploadUrlPayload {
+    UploadUrl;
+    ProviderKey;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreatePreAuthUploadUrlPayload.prototype, "UploadUrl", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CreatePreAuthUploadUrlPayload.prototype, "ProviderKey", void 0);
+CreatePreAuthUploadUrlPayload = __decorate([
+    ObjectType()
+], CreatePreAuthUploadUrlPayload);
+export { CreatePreAuthUploadUrlPayload };
+let DeleteStorageObjectInput = class DeleteStorageObjectInput {
+    AccountID;
+    ObjectName;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], DeleteStorageObjectInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], DeleteStorageObjectInput.prototype, "ObjectName", void 0);
+DeleteStorageObjectInput = __decorate([
+    InputType()
+], DeleteStorageObjectInput);
+export { DeleteStorageObjectInput };
+let MoveStorageObjectInput = class MoveStorageObjectInput {
+    AccountID;
+    OldName;
+    NewName;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MoveStorageObjectInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MoveStorageObjectInput.prototype, "OldName", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MoveStorageObjectInput.prototype, "NewName", void 0);
+MoveStorageObjectInput = __decorate([
+    InputType()
+], MoveStorageObjectInput);
+export { MoveStorageObjectInput };
+let CopyStorageObjectInput = class CopyStorageObjectInput {
+    AccountID;
+    SourceName;
+    DestinationName;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyStorageObjectInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyStorageObjectInput.prototype, "SourceName", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyStorageObjectInput.prototype, "DestinationName", void 0);
+CopyStorageObjectInput = __decorate([
+    InputType()
+], CopyStorageObjectInput);
+export { CopyStorageObjectInput };
+let CreateDirectoryInput = class CreateDirectoryInput {
+    AccountID;
+    Path;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateDirectoryInput.prototype, "AccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateDirectoryInput.prototype, "Path", void 0);
+CreateDirectoryInput = __decorate([
+    InputType()
+], CreateDirectoryInput);
+export { CreateDirectoryInput };
+let CopyObjectBetweenAccountsInput = class CopyObjectBetweenAccountsInput {
+    SourceAccountID;
+    DestinationAccountID;
+    SourcePath;
+    DestinationPath;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsInput.prototype, "SourceAccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsInput.prototype, "DestinationAccountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsInput.prototype, "SourcePath", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsInput.prototype, "DestinationPath", void 0);
+CopyObjectBetweenAccountsInput = __decorate([
+    InputType()
+], CopyObjectBetweenAccountsInput);
+export { CopyObjectBetweenAccountsInput };
+let CopyObjectBetweenAccountsPayload = class CopyObjectBetweenAccountsPayload {
+    success;
+    message;
+    bytesTransferred;
+    sourceAccount;
+    destinationAccount;
+    sourcePath;
+    destinationPath;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], CopyObjectBetweenAccountsPayload.prototype, "success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsPayload.prototype, "message", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], CopyObjectBetweenAccountsPayload.prototype, "bytesTransferred", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsPayload.prototype, "sourceAccount", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsPayload.prototype, "destinationAccount", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsPayload.prototype, "sourcePath", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CopyObjectBetweenAccountsPayload.prototype, "destinationPath", void 0);
+CopyObjectBetweenAccountsPayload = __decorate([
+    ObjectType()
+], CopyObjectBetweenAccountsPayload);
+export { CopyObjectBetweenAccountsPayload };
+let SearchAcrossAccountsInput = class SearchAcrossAccountsInput {
+    AccountIDs;
+    Query;
+    MaxResultsPerAccount;
+    FileTypes;
+    SearchContent;
+};
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], SearchAcrossAccountsInput.prototype, "AccountIDs", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], SearchAcrossAccountsInput.prototype, "Query", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], SearchAcrossAccountsInput.prototype, "MaxResultsPerAccount", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SearchAcrossAccountsInput.prototype, "FileTypes", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], SearchAcrossAccountsInput.prototype, "SearchContent", void 0);
+SearchAcrossAccountsInput = __decorate([
+    InputType()
+], SearchAcrossAccountsInput);
+export { SearchAcrossAccountsInput };
+let FileSearchResultPayload = class FileSearchResultPayload {
+    path;
+    name;
+    size;
+    contentType;
+    lastModified;
+    relevance;
+    excerpt;
+    matchInFilename;
+    objectId;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "path", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "name", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], FileSearchResultPayload.prototype, "size", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "contentType", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "lastModified", void 0);
+__decorate([
+    Field(() => Number, { nullable: true }),
+    __metadata("design:type", Number)
+], FileSearchResultPayload.prototype, "relevance", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "excerpt", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], FileSearchResultPayload.prototype, "matchInFilename", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], FileSearchResultPayload.prototype, "objectId", void 0);
+FileSearchResultPayload = __decorate([
+    ObjectType()
+], FileSearchResultPayload);
+export { FileSearchResultPayload };
+let AccountSearchResultPayload = class AccountSearchResultPayload {
+    accountID;
+    accountName;
+    success;
+    errorMessage;
+    results;
+    totalMatches;
+    hasMore;
+    nextPageToken;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AccountSearchResultPayload.prototype, "accountID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AccountSearchResultPayload.prototype, "accountName", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AccountSearchResultPayload.prototype, "success", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], AccountSearchResultPayload.prototype, "errorMessage", void 0);
+__decorate([
+    Field(() => [FileSearchResultPayload]),
+    __metadata("design:type", Array)
+], AccountSearchResultPayload.prototype, "results", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], AccountSearchResultPayload.prototype, "totalMatches", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AccountSearchResultPayload.prototype, "hasMore", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], AccountSearchResultPayload.prototype, "nextPageToken", void 0);
+AccountSearchResultPayload = __decorate([
+    ObjectType()
+], AccountSearchResultPayload);
+export { AccountSearchResultPayload };
+let SearchAcrossAccountsPayload = class SearchAcrossAccountsPayload {
+    accountResults;
+    totalResultsReturned;
+    successfulAccounts;
+    failedAccounts;
+};
+__decorate([
+    Field(() => [AccountSearchResultPayload]),
+    __metadata("design:type", Array)
+], SearchAcrossAccountsPayload.prototype, "accountResults", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], SearchAcrossAccountsPayload.prototype, "totalResultsReturned", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], SearchAcrossAccountsPayload.prototype, "successfulAccounts", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], SearchAcrossAccountsPayload.prototype, "failedAccounts", void 0);
+SearchAcrossAccountsPayload = __decorate([
+    ObjectType()
+], SearchAcrossAccountsPayload);
+export { SearchAcrossAccountsPayload };
 let FileResolver = class FileResolver extends FileResolverBase {
+    buildUserContext(context) {
+        const user = this.GetUserFromPayload(context.userPayload);
+        return {
+            userID: user.ID,
+            contextUser: user,
+        };
+    }
+    buildExtendedUserContext(context, accountEntity) {
+        const user = this.GetUserFromPayload(context.userPayload);
+        return {
+            userID: user.ID,
+            contextUser: user,
+            accountEntity,
+        };
+    }
+    async loadAccountAndProvider(accountId, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const account = await md.GetEntityObject('MJ: File Storage Accounts', user);
+        const loaded = await account.Load(accountId);
+        if (!loaded) {
+            throw new Error(`Storage account with ID ${accountId} not found`);
+        }
+        const provider = await md.GetEntityObject('File Storage Providers', user);
+        await provider.Load(account.ProviderID);
+        return { account, provider };
+    }
     async CreateFile(input, context, pubSub) {
         const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
         const user = this.GetUserFromPayload(context.userPayload);
@@ -72,21 +535,23 @@ let FileResolver = class FileResolver extends FileResolverBase {
         if (!success) {
             return null;
         }
-        const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity);
+        const userContext = this.buildUserContext(context);
+        const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity, userContext);
         const mapper = new FieldMapper();
         fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }), true, true);
         await fileEntity.Save();
         const File = mapper.MapFields({ ...fileEntity.GetAll() });
         return { File, UploadUrl, NameExists };
     }
-    async DownloadUrl(file, { userPayload }) {
+    async DownloadUrl(file, context) {
         const md = new Metadata();
-        const user = this.GetUserFromPayload(userPayload);
+        const user = this.GetUserFromPayload(context.userPayload);
         const fileEntity = await md.GetEntityObject('Files', user);
         fileEntity.CheckPermissions(EntityPermissionType.Read, true);
         const providerEntity = await md.GetEntityObject('File Storage Providers', user);
         await providerEntity.Load(file.ProviderID);
-        const url = await createDownloadUrl(providerEntity, file.ProviderKey ?? file.Name);
+        const userContext = this.buildUserContext(context);
+        const url = await createDownloadUrl(providerEntity, file.ProviderKey ?? file.Name, userContext);
         return url;
     }
     async UpdateFile(input, context, pubSub) {
@@ -98,7 +563,8 @@ let FileResolver = class FileResolver extends FileResolverBase {
         if (fileEntity.Name !== input.Name) {
             const providerEntity = await md.GetEntityObject('File Storage Providers', user);
             await providerEntity.Load(fileEntity.ProviderID);
-            const success = await moveObject(providerEntity, fileEntity.Name, input.Name);
+            const userContext = this.buildUserContext(context);
+            const success = await moveObject(providerEntity, fileEntity.Name, input.Name, userContext);
             if (!success) {
                 throw new Error('Error updating object name');
             }
@@ -118,10 +584,247 @@ let FileResolver = class FileResolver extends FileResolverBase {
         if (fileEntity.Status === 'Uploaded') {
             const providerEntity = await md.GetEntityObject('File Storage Providers', userInfo);
             await providerEntity.Load(fileEntity.ProviderID);
-            await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name);
+            const userContext = this.buildUserContext(context);
+            await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name, userContext);
         }
         return super.DeleteMJFile(ID, options, context, pubSub);
     }
+    async ListStorageObjects(input, context) {
+        console.log('[FileResolver] ListStorageObjects called with:', {
+            AccountID: input.AccountID,
+            Prefix: input.Prefix,
+            Delimiter: input.Delimiter,
+        });
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        console.log('[FileResolver] Provider loaded:', {
+            Name: providerEntity.Name,
+            ServerDriverKey: providerEntity.ServerDriverKey,
+            HasConfiguration: !!providerEntity.Get('Configuration'),
+        });
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+        const userContext = this.buildExtendedUserContext(context, account);
+        const result = await listObjects(providerEntity, input.Prefix, input.Delimiter || '/', userContext);
+        console.log('[FileResolver] listObjects result:', {
+            objectsCount: result.objects.length,
+            prefixesCount: result.prefixes.length,
+            objects: result.objects.map((o) => ({ name: o.name, isDirectory: o.isDirectory })),
+            prefixes: result.prefixes,
+        });
+        const objects = result.objects.map((obj) => ({
+            ...obj,
+            lastModified: obj.lastModified.toISOString(),
+        }));
+        return {
+            objects,
+            prefixes: result.prefixes,
+        };
+    }
+    async CreatePreAuthDownloadUrl(input, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+        const userContext = this.buildExtendedUserContext(context, account);
+        const downloadUrl = await createDownloadUrl(providerEntity, input.ObjectName, userContext);
+        return downloadUrl;
+    }
+    async CreatePreAuthUploadUrl(input, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+        const userContext = this.buildExtendedUserContext(context, account);
+        const { UploadUrl, updatedInput } = await createUploadUrl(providerEntity, {
+            ID: '',
+            Name: input.ObjectName,
+            ProviderID: providerEntity.ID,
+            ContentType: input.ContentType,
+        }, userContext);
+        const providerKey = updatedInput.ProviderKey;
+        return {
+            UploadUrl,
+            ProviderKey: providerKey,
+        };
+    }
+    async DeleteStorageObject(input, context) {
+        console.log('[FileResolver] DeleteStorageObject called:', input);
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        console.log('[FileResolver] Provider loaded:', {
+            providerID: providerEntity.ID,
+            providerName: providerEntity.Name,
+            serverDriverKey: providerEntity.ServerDriverKey,
+        });
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Delete, true);
+        console.log('[FileResolver] Permissions checked, calling deleteObject...');
+        const userContext = this.buildExtendedUserContext(context, account);
+        const success = await deleteObject(providerEntity, input.ObjectName, userContext);
+        console.log('[FileResolver] deleteObject returned:', success);
+        return success;
+    }
+    async MoveStorageObject(input, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Update, true);
+        const userContext = this.buildExtendedUserContext(context, account);
+        const success = await moveObject(providerEntity, input.OldName, input.NewName, userContext);
+        return success;
+    }
+    async CopyStorageObject(input, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+        fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+        const userContext = this.buildExtendedUserContext(context, account);
+        const success = await copyObject(providerEntity, input.SourceName, input.DestinationName, userContext);
+        return success;
+    }
+    async CreateDirectory(input, context) {
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const { account: accountEntity, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+        const driver = await initializeDriverWithAccountCredentials({
+            accountEntity,
+            providerEntity,
+            contextUser: user,
+        });
+        const success = await driver.CreateDirectory(input.Path);
+        return success;
+    }
+    async CopyObjectBetweenAccounts(input, context) {
+        console.log('[FileResolver] CopyObjectBetweenAccounts called:', {
+            sourceAccountID: input.SourceAccountID,
+            destinationAccountID: input.DestinationAccountID,
+            sourcePath: input.SourcePath,
+            destinationPath: input.DestinationPath,
+        });
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+        fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+        const { account: sourceAccount, provider: sourceProviderEntity } = await this.loadAccountAndProvider(input.SourceAccountID, context);
+        const { account: destAccount, provider: destProviderEntity } = await this.loadAccountAndProvider(input.DestinationAccountID, context);
+        const sourceUserContext = this.buildExtendedUserContext(context, sourceAccount);
+        const destUserContext = this.buildExtendedUserContext(context, destAccount);
+        const result = await copyObjectBetweenProviders(sourceProviderEntity, destProviderEntity, input.SourcePath, input.DestinationPath, {
+            sourceUserContext,
+            destinationUserContext: destUserContext,
+        });
+        console.log('[FileResolver] CopyObjectBetweenAccounts result:', result);
+        return {
+            success: result.success,
+            message: result.message,
+            bytesTransferred: result.bytesTransferred,
+            sourceAccount: sourceAccount.Name,
+            destinationAccount: destAccount.Name,
+            sourcePath: result.sourcePath,
+            destinationPath: result.destinationPath,
+        };
+    }
+    async SearchAcrossAccounts(input, context) {
+        console.log('[FileResolver] SearchAcrossAccounts called:', {
+            accountIDs: input.AccountIDs,
+            query: input.Query,
+            maxResultsPerAccount: input.MaxResultsPerAccount,
+            fileTypes: input.FileTypes,
+            searchContent: input.SearchContent,
+        });
+        const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+        const user = this.GetUserFromPayload(context.userPayload);
+        const fileEntity = await md.GetEntityObject('Files', user);
+        fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+        const rv = new RunView();
+        const quotedIDs = input.AccountIDs.map((id) => `'${id}'`).join(', ');
+        const accountResult = await rv.RunView({
+            EntityName: 'MJ: File Storage Accounts',
+            ExtraFilter: `ID IN (${quotedIDs})`,
+            ResultType: 'entity_object',
+        }, user);
+        if (!accountResult.Success) {
+            throw new Error(`Failed to load storage accounts: ${accountResult.ErrorMessage}`);
+        }
+        const accountEntities = accountResult.Results;
+        if (accountEntities.length === 0) {
+            throw new Error('No valid storage accounts found for the provided IDs');
+        }
+        if (accountEntities.length < input.AccountIDs.length) {
+            const foundIDs = new Set(accountEntities.map((a) => a.ID));
+            const missingIDs = input.AccountIDs.filter((id) => !foundIDs.has(id));
+            console.warn(`[FileResolver] Accounts not found: ${missingIDs.join(', ')}`);
+        }
+        const providerIDs = [...new Set(accountEntities.map((a) => a.ProviderID))];
+        const quotedProviderIDs = providerIDs.map((id) => `'${id}'`).join(', ');
+        const providerResult = await rv.RunView({
+            EntityName: 'File Storage Providers',
+            ExtraFilter: `ID IN (${quotedProviderIDs})`,
+            ResultType: 'entity_object',
+        }, user);
+        if (!providerResult.Success) {
+            throw new Error(`Failed to load storage providers: ${providerResult.ErrorMessage}`);
+        }
+        const providerMap = new Map();
+        for (const provider of providerResult.Results) {
+            providerMap.set(provider.ID, provider);
+        }
+        const accountInputs = [];
+        for (const account of accountEntities) {
+            const provider = providerMap.get(account.ProviderID);
+            if (provider) {
+                accountInputs.push({ accountEntity: account, providerEntity: provider });
+            }
+        }
+        const result = await searchAcrossAccounts(accountInputs, input.Query, {
+            maxResultsPerAccount: input.MaxResultsPerAccount,
+            fileTypes: input.FileTypes,
+            searchContent: input.SearchContent,
+            contextUser: user,
+        });
+        console.log('[FileResolver] SearchAcrossAccounts result:', {
+            totalResultsReturned: result.totalResultsReturned,
+            successfulAccounts: result.successfulAccounts,
+            failedAccounts: result.failedAccounts,
+        });
+        const accountResults = result.accountResults.map((ar) => ({
+            accountID: ar.accountID,
+            accountName: ar.accountName,
+            success: ar.success,
+            errorMessage: ar.errorMessage,
+            results: ar.results.map((r) => ({
+                path: r.path,
+                name: r.name,
+                size: r.size,
+                contentType: r.contentType,
+                lastModified: r.lastModified.toISOString(),
+                relevance: r.relevance,
+                excerpt: r.excerpt,
+                matchInFilename: r.matchInFilename,
+                objectId: r.objectId,
+            })),
+            totalMatches: ar.totalMatches,
+            hasMore: ar.hasMore,
+            nextPageToken: ar.nextPageToken,
+        }));
+        return {
+            accountResults,
+            totalResultsReturned: result.totalResultsReturned,
+            successfulAccounts: result.successfulAccounts,
+            failedAccounts: result.failedAccounts,
+        };
+    }
 };
 __decorate([
     Mutation(() => CreateFilePayload),
@@ -159,6 +862,78 @@ __decorate([
     __metadata("design:paramtypes", [String, DeleteOptionsInput, Object, PubSubEngine]),
     __metadata("design:returntype", Promise)
 ], FileResolver.prototype, "DeleteFile", null);
+__decorate([
+    Query(() => StorageListResult),
+    __param(0, Arg('input', () => ListStorageObjectsInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ListStorageObjectsInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "ListStorageObjects", null);
+__decorate([
+    Query(() => String),
+    __param(0, Arg('input', () => CreatePreAuthDownloadUrlInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreatePreAuthDownloadUrlInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "CreatePreAuthDownloadUrl", null);
+__decorate([
+    Mutation(() => CreatePreAuthUploadUrlPayload),
+    __param(0, Arg('input', () => CreatePreAuthUploadUrlInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreatePreAuthUploadUrlInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "CreatePreAuthUploadUrl", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Arg('input', () => DeleteStorageObjectInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [DeleteStorageObjectInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "DeleteStorageObject", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Arg('input', () => MoveStorageObjectInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MoveStorageObjectInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "MoveStorageObject", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Arg('input', () => CopyStorageObjectInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CopyStorageObjectInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "CopyStorageObject", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Arg('input', () => CreateDirectoryInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateDirectoryInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "CreateDirectory", null);
+__decorate([
+    Mutation(() => CopyObjectBetweenAccountsPayload),
+    __param(0, Arg('input', () => CopyObjectBetweenAccountsInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CopyObjectBetweenAccountsInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "CopyObjectBetweenAccounts", null);
+__decorate([
+    Query(() => SearchAcrossAccountsPayload),
+    __param(0, Arg('input', () => SearchAcrossAccountsInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [SearchAcrossAccountsInput, Object]),
+    __metadata("design:returntype", Promise)
+], FileResolver.prototype, "SearchAcrossAccounts", null);
 FileResolver = __decorate([
     Resolver(MJFile_)
 ], FileResolver);