@internxt/cli 0.1.4

package/dist/services/drive/drive-file.service.d.ts

@@ -0,0 +1,15 @@
+import { StorageTypes } from '@internxt/sdk/dist/drive';
+import { DriveFileItem } from '../../types/drive.types';
+export declare class DriveFileService {
+    static readonly instance: DriveFileService;
+    createFile: (payload: {
+        name: string;
+        type: string;
+        size: number;
+        folderId: number;
+        fileId: string;
+        bucket: string;
+    }) => Promise<DriveFileItem>;
+    getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
+    moveFile: (payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
+}

package/dist/services/drive/drive-file.service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFileService = void 0;
+const lib_1 = require("@internxt/lib");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+const sdk_manager_service_1 = require("../sdk-manager.service");
+const config_service_1 = require("../config.service");
+const crypto_utils_1 = require("../../utils/crypto.utils");
+const drive_utils_1 = require("../../utils/drive.utils");
+class DriveFileService {
+    static instance = new DriveFileService();
+    createFile = async (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const encryptedName = lib_1.aes.encrypt(payload.name, `${config_service_1.ConfigService.instance.get('APP_CRYPTO_SECRET2')}-${payload.folderId}`, crypto_utils_1.CryptoUtils.getAesInit());
+        const driveFile = await storageClient.createFileEntry({
+            name: encryptedName,
+            size: payload.size,
+            folder_id: payload.folderId,
+            id: payload.fileId,
+            type: payload.type,
+            plain_name: payload.name,
+            bucket: payload.bucket,
+            encrypt_version: types_1.EncryptionVersion.Aes03,
+        });
+        return {
+            size: Number(driveFile.size),
+            uuid: driveFile.uuid,
+            encryptedName,
+            name: payload.name,
+            bucket: payload.bucket,
+            createdAt: new Date(driveFile.createdAt),
+            updatedAt: new Date(driveFile.updatedAt),
+            fileId: payload.fileId,
+            id: driveFile.id,
+            type: payload.type,
+            status: driveFile.status,
+            folderId: driveFile.folderId,
+        };
+    };
+    getFileMetadata = async (uuid) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const [getFileMetadata] = storageClient.getFile(uuid);
+        const fileMetadata = await getFileMetadata;
+        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
+    };
+    moveFile = (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.moveFileByUuid(payload);
+    };
+}
+exports.DriveFileService = DriveFileService;

package/dist/services/drive/drive-folder.service.d.ts

@@ -0,0 +1,15 @@
+import { FetchPaginatedFile, FetchPaginatedFolder } from '@internxt/sdk/dist/drive/storage/types';
+import { StorageTypes } from '@internxt/sdk/dist/drive';
+import { DriveFolderItem } from '../../types/drive.types';
+export declare class DriveFolderService {
+    static readonly instance: DriveFolderService;
+    getFolderMetaByUuid: (uuid: string) => Promise<DriveFolderItem>;
+    getFolderMetaById: (id: number) => Promise<DriveFolderItem>;
+    getFolderContent: (folderUuid: string) => Promise<{
+        folders: FetchPaginatedFolder[];
+        files: FetchPaginatedFile[];
+    }>;
+    private getAllSubfolders;
+    private getAllSubfiles;
+    moveFolder: (payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
+}

package/dist/services/drive/drive-folder.service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFolderService = void 0;
+const sdk_manager_service_1 = require("../sdk-manager.service");
+const drive_utils_1 = require("../../utils/drive.utils");
+class DriveFolderService {
+    static instance = new DriveFolderService();
+    getFolderMetaByUuid = async (uuid) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const folderMeta = await storageClient.getFolderMeta(uuid);
+        return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+    };
+    getFolderMetaById = async (id) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const folderMeta = await storageClient.getFolderMetaById(id);
+        return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+    };
+    getFolderContent = async (folderUuid) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const folders = await this.getAllSubfolders(storageClient, folderUuid, 0);
+        const files = await this.getAllSubfiles(storageClient, folderUuid, 0);
+        return { folders, files };
+    };
+    getAllSubfolders = async (storageClient, folderUuid, offset) => {
+        const [folderContentPromise] = storageClient.getFolderFoldersByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+        const { folders } = await folderContentPromise;
+        if (folders.length > 0) {
+            return folders.concat(await this.getAllSubfolders(storageClient, folderUuid, offset + folders.length));
+        }
+        else {
+            return folders;
+        }
+    };
+    getAllSubfiles = async (storageClient, folderUuid, offset) => {
+        const [folderContentPromise] = storageClient.getFolderFilesByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+        const { files } = await folderContentPromise;
+        if (files.length > 0) {
+            return files.concat(await this.getAllSubfiles(storageClient, folderUuid, offset + files.length));
+        }
+        else {
+            return files;
+        }
+    };
+    moveFolder = (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.moveFolderByUuid(payload);
+    };
+}
+exports.DriveFolderService = DriveFolderService;

package/dist/services/drive/trash.service.d.ts

@@ -0,0 +1,5 @@
+import { StorageTypes } from '@internxt/sdk/dist/drive';
+export declare class TrashService {
+    static readonly instance: TrashService;
+    trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
+}

package/dist/services/drive/trash.service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrashService = void 0;
+const sdk_manager_service_1 = require("../sdk-manager.service");
+class TrashService {
+    static instance = new TrashService();
+    trashItems = (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.addItemsToTrash(payload);
+    };
+}
+exports.TrashService = TrashService;

package/dist/services/keys.service.d.ts

@@ -0,0 +1,14 @@
+export declare class KeysService {
+    static readonly instance: KeysService;
+    assertPrivateKeyIsValid: (privateKey: string, password: string) => Promise<void>;
+    encryptPrivateKey: (privateKey: string, password: string) => string;
+    decryptPrivateKey: (privateKey: string, password: string) => string;
+    assertValidateKeys: (privateKey: string, publicKey: string) => Promise<void>;
+    isValidKey: (key: string) => Promise<boolean>;
+    generateNewKeysWithEncrypted: (password: string) => Promise<{
+        privateKeyArmored: string;
+        privateKeyArmoredEncrypted: string;
+        publicKeyArmored: string;
+        revocationCertificate: string;
+    }>;
+}

package/dist/services/keys.service.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeysService = void 0;
+const lib_1 = require("@internxt/lib");
+const openpgp = __importStar(require("openpgp"));
+const keys_types_1 = require("../types/keys.types");
+const crypto_utils_1 = require("../utils/crypto.utils");
+class KeysService {
+    static instance = new KeysService();
+    assertPrivateKeyIsValid = async (privateKey, password) => {
+        let privateKeyDecrypted;
+        let badIterations = true;
+        try {
+            lib_1.aes.decrypt(privateKey, password, 9999);
+        }
+        catch {
+            badIterations = false;
+        }
+        if (badIterations === true)
+            throw new keys_types_1.WrongIterationsToEncryptPrivateKeyError();
+        let badEncrypted = false;
+        try {
+            privateKeyDecrypted = this.decryptPrivateKey(privateKey, password);
+        }
+        catch {
+            badEncrypted = true;
+        }
+        let hasValidFormat = false;
+        try {
+            if (privateKeyDecrypted !== undefined) {
+                hasValidFormat = await this.isValidKey(privateKeyDecrypted);
+            }
+        }
+        catch {
+        }
+        if (badEncrypted === true)
+            throw new keys_types_1.CorruptedEncryptedPrivateKeyError();
+        if (hasValidFormat === false)
+            throw new keys_types_1.BadEncodedPrivateKeyError();
+    };
+    encryptPrivateKey = (privateKey, password) => {
+        return lib_1.aes.encrypt(privateKey, password, crypto_utils_1.CryptoUtils.getAesInit());
+    };
+    decryptPrivateKey = (privateKey, password) => {
+        return lib_1.aes.decrypt(privateKey, password);
+    };
+    assertValidateKeys = async (privateKey, publicKey) => {
+        const publicKeyArmored = await openpgp.readKey({ armoredKey: publicKey });
+        const privateKeyArmored = await openpgp.readPrivateKey({ armoredKey: privateKey });
+        const plainMessage = 'validate-keys';
+        const originalText = await openpgp.createMessage({ text: plainMessage });
+        const encryptedMessage = await openpgp.encrypt({
+            message: originalText,
+            encryptionKeys: publicKeyArmored,
+        });
+        const decryptedMessage = (await openpgp.decrypt({
+            message: await openpgp.readMessage({ armoredMessage: encryptedMessage }),
+            verificationKeys: publicKeyArmored,
+            decryptionKeys: privateKeyArmored,
+        })).data;
+        if (decryptedMessage !== plainMessage) {
+            throw new keys_types_1.KeysDoNotMatchError();
+        }
+    };
+    isValidKey = async (key) => {
+        try {
+            await openpgp.readKey({ armoredKey: key });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    generateNewKeysWithEncrypted = async (password) => {
+        const { privateKey, publicKey, revocationCertificate } = await openpgp.generateKey({
+            userIDs: [{ email: 'inxt@inxt.com' }],
+            curve: 'ed25519',
+        });
+        return {
+            privateKeyArmored: privateKey,
+            privateKeyArmoredEncrypted: this.encryptPrivateKey(privateKey, password),
+            publicKeyArmored: Buffer.from(publicKey).toString('base64'),
+            revocationCertificate: Buffer.from(revocationCertificate).toString('base64'),
+        };
+    };
+}
+exports.KeysService = KeysService;

package/dist/services/network/download.service.d.ts

@@ -0,0 +1,7 @@
+export declare class DownloadService {
+    static readonly instance: DownloadService;
+    downloadFile(url: string, options: {
+        progressCallback?: (progress: number) => void;
+        abortController?: AbortController;
+    }): Promise<ReadableStream<Uint8Array>>;
+}

package/dist/services/network/download.service.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadService = void 0;
+const axios_1 = __importDefault(require("axios"));
+class DownloadService {
+    static instance = new DownloadService();
+    async downloadFile(url, options) {
+        const response = await axios_1.default.get(url, {
+            responseType: 'stream',
+            onDownloadProgress(progressEvent) {
+                if (options.progressCallback && progressEvent.total) {
+                    const reportedProgress = progressEvent.loaded / progressEvent.total;
+                    options.progressCallback(reportedProgress);
+                }
+            },
+        });
+        const readable = new ReadableStream({
+            start(controller) {
+                response.data.on('data', (chunk) => {
+                    controller.enqueue(chunk);
+                });
+                response.data.on('end', () => {
+                    controller.close();
+                });
+            },
+        });
+        return readable;
+    }
+}
+exports.DownloadService = DownloadService;

package/dist/services/network/network-facade.service.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Network } from '@internxt/sdk';
+import { DownloadOptions, UploadOptions } from '../../types/network.types';
+import { CryptoService } from '../crypto.service';
+import { UploadService } from './upload.service';
+import { DownloadService } from './download.service';
+import { Readable } from 'node:stream';
+export declare class NetworkFacade {
+    private readonly network;
+    private readonly uploadService;
+    private readonly downloadService;
+    private readonly cryptoService;
+    private readonly cryptoLib;
+    constructor(network: Network.Network, uploadService: UploadService, downloadService: DownloadService, cryptoService: CryptoService);
+    downloadToStream(bucketId: string, mnemonic: string, fileId: string, to: WritableStream, options?: DownloadOptions): Promise<[Promise<void>, AbortController]>;
+    uploadFromStream(bucketId: string, mnemonic: string, size: number, from: Readable, options?: UploadOptions): Promise<[Promise<{
+        fileId: string;
+        hash: Buffer;
+    }>, AbortController]>;
+}

package/dist/services/network/network-facade.service.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkFacade = void 0;
+const sdk_1 = require("@internxt/sdk");
+const NetworkUpload = __importStar(require("@internxt/sdk/dist/network/upload"));
+const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
+const inxt_js_1 = require("@internxt/inxt-js");
+const crypto_1 = __importDefault(require("crypto"));
+const validation_service_1 = require("../validation.service");
+const hash_utils_1 = require("../../utils/hash.utils");
+class NetworkFacade {
+    network;
+    uploadService;
+    downloadService;
+    cryptoService;
+    cryptoLib;
+    constructor(network, uploadService, downloadService, cryptoService) {
+        this.network = network;
+        this.uploadService = uploadService;
+        this.downloadService = downloadService;
+        this.cryptoService = cryptoService;
+        this.cryptoLib = {
+            algorithm: sdk_1.Network.ALGORITHMS.AES256CTR,
+            validateMnemonic: (mnemonic) => {
+                return validation_service_1.ValidationService.instance.validateMnemonic(mnemonic);
+            },
+            generateFileKey: (mnemonic, bucketId, index) => {
+                return inxt_js_1.Environment.utils.generateFileKey(mnemonic, bucketId, index);
+            },
+            randomBytes: crypto_1.default.randomBytes,
+        };
+    }
+    async downloadToStream(bucketId, mnemonic, fileId, to, options) {
+        const encryptedContentStreams = [];
+        let fileStream;
+        const abortable = options?.abortController ?? new AbortController();
+        const onProgress = (progress) => {
+            if (!options?.progressCallback)
+                return;
+            options.progressCallback(progress);
+        };
+        const onDownloadProgress = (progress) => {
+            onProgress(progress);
+        };
+        const decryptFile = async (_, key, iv) => {
+            fileStream = await this.cryptoService.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv));
+            await fileStream.pipeTo(to);
+        };
+        const downloadFile = async (downloadables) => {
+            for (const downloadable of downloadables) {
+                if (abortable.signal.aborted) {
+                    throw new Error('Download aborted');
+                }
+                const encryptedContentStream = await this.downloadService.downloadFile(downloadable.url, {
+                    progressCallback: onDownloadProgress,
+                    abortController: options?.abortController,
+                });
+                encryptedContentStreams.push(encryptedContentStream);
+            }
+        };
+        const downloadOperation = async () => {
+            await NetworkDownload.downloadFile(fileId, bucketId, mnemonic, this.network, this.cryptoLib, Buffer.from, downloadFile, decryptFile);
+        };
+        return [downloadOperation(), abortable];
+    }
+    async uploadFromStream(bucketId, mnemonic, size, from, options) {
+        const hashStream = new hash_utils_1.HashStream();
+        const abortable = options?.abortController ?? new AbortController();
+        let fileHash;
+        let encryptionTransform;
+        const onProgress = (progress) => {
+            if (!options?.progressCallback)
+                return;
+            options.progressCallback(progress);
+        };
+        const onUploadProgress = (progress) => {
+            onProgress(progress * 0.9);
+        };
+        const encryptFile = async (_, key, iv) => {
+            encryptionTransform = from
+                .pipe(await this.cryptoService.getEncryptionTransform(Buffer.from(key), Buffer.from(iv)))
+                .pipe(hashStream);
+        };
+        const uploadFile = async (url) => {
+            await this.uploadService.uploadFile(url, encryptionTransform, {
+                abortController: abortable,
+                progressCallback: onUploadProgress,
+            });
+            return hashStream.getHash().toString('hex');
+        };
+        const uploadOperation = async () => {
+            const uploadResult = await NetworkUpload.uploadFile(this.network, this.cryptoLib, bucketId, mnemonic, size, encryptFile, uploadFile);
+            onProgress(1);
+            return {
+                fileId: uploadResult,
+                hash: fileHash,
+            };
+        };
+        return [uploadOperation(), abortable];
+    }
+}
+exports.NetworkFacade = NetworkFacade;

package/dist/services/network/upload.service.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Readable } from 'node:stream';
+import { UploadOptions } from '../../types/network.types';
+export declare class UploadService {
+    static readonly instance: UploadService;
+    uploadFile(url: string, from: Readable, options: UploadOptions): Promise<{
+        etag: string;
+    }>;
+}

package/dist/services/network/upload.service.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadService = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class UploadService {
+    static instance = new UploadService();
+    async uploadFile(url, from, options) {
+        const response = await (0, node_fetch_1.default)(url, { method: 'PUT', body: from, signal: options.abortController?.signal });
+        const etag = response.headers.get('etag');
+        options.progressCallback(1);
+        if (!etag) {
+            throw new Error('Missing Etag in response when uploading file');
+        }
+        return { etag };
+    }
+}
+exports.UploadService = UploadService;

package/dist/services/realms/drive-files.realm.d.ts

@@ -0,0 +1,23 @@
+import Realm, { ObjectSchema } from 'realm';
+import { DriveFileItem } from '../../types/drive.types';
+export declare class DriveFileRealmSchema extends Realm.Object<DriveFileRealmSchema> {
+    id: number;
+    name: string;
+    type?: string;
+    uuid: string;
+    file_id: string;
+    folder_id: number;
+    bucket: string;
+    relative_path: string;
+    created_at: Date;
+    updated_at: Date;
+    size: number;
+    status: 'EXISTS' | 'REMOVED' | 'TRASHED';
+    static readonly schema: ObjectSchema;
+}
+export declare class DriveFilesRealm {
+    private realm;
+    constructor(realm: Realm);
+    findByRelativePath(relativePath: string): DriveFileRealmSchema | null;
+    createOrReplace(driveFile: DriveFileItem, relativePath: string): void;
+}

package/dist/services/realms/drive-files.realm.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFilesRealm = exports.DriveFileRealmSchema = void 0;
+const realm_1 = __importDefault(require("realm"));
+class DriveFileRealmSchema extends realm_1.default.Object {
+    id;
+    name;
+    type;
+    uuid;
+    file_id;
+    folder_id;
+    bucket;
+    relative_path;
+    created_at;
+    updated_at;
+    size;
+    status;
+    static schema = {
+        name: 'DriveFile',
+        properties: {
+            id: 'int',
+            name: 'string',
+            type: 'string?',
+            uuid: { type: 'string', indexed: true },
+            file_id: 'string',
+            folder_id: 'int',
+            bucket: 'string',
+            relative_path: { type: 'string', indexed: true },
+            created_at: 'date',
+            updated_at: 'date',
+            size: 'int',
+            status: 'string',
+        },
+        primaryKey: 'id',
+    };
+}
+exports.DriveFileRealmSchema = DriveFileRealmSchema;
+class DriveFilesRealm {
+    realm;
+    constructor(realm) {
+        this.realm = realm;
+    }
+    findByRelativePath(relativePath) {
+        const object = this.realm
+            .objects('DriveFile')
+            .filtered('relative_path = $0', relativePath)
+            .find((file) => file.relative_path === relativePath);
+        return object ?? null;
+    }
+    createOrReplace(driveFile, relativePath) {
+        const existingObject = this.realm.objectForPrimaryKey('DriveFile', driveFile.id);
+        this.realm.write(() => {
+            if (existingObject) {
+                this.realm.delete(existingObject);
+            }
+            this.realm.create('DriveFile', {
+                id: driveFile.id,
+                name: driveFile.name,
+                type: driveFile.type,
+                uuid: driveFile.uuid,
+                file_id: driveFile.fileId,
+                folder_id: driveFile.folderId,
+                bucket: driveFile.bucket,
+                relative_path: relativePath,
+                created_at: driveFile.createdAt,
+                updated_at: driveFile.updatedAt,
+                size: driveFile.size,
+                status: 'EXISTS',
+            });
+        });
+    }
+}
+exports.DriveFilesRealm = DriveFilesRealm;

package/dist/services/realms/drive-folders.realm.d.ts

@@ -0,0 +1,20 @@
+import Realm, { ObjectSchema } from 'realm';
+import { DriveFolderItem } from '../../types/drive.types';
+export declare class DriveFolderRealmSchema extends Realm.Object<DriveFolderRealmSchema> {
+    id: number;
+    name: string;
+    uuid: string;
+    relative_path: string;
+    parent_id?: number;
+    created_at: Date;
+    updated_at: Date;
+    status: 'EXISTS' | 'REMOVED' | 'TRASHED';
+    static readonly schema: ObjectSchema;
+}
+export declare class DriveFoldersRealm {
+    private realm;
+    constructor(realm: Realm);
+    findByRelativePath(relativePath: string): DriveFolderRealmSchema | null;
+    findByParentId(parentId: number | null): DriveFolderRealmSchema | null;
+    createOrReplace(driveFolder: DriveFolderItem, relativePath: string): void;
+}