@internxt/cli 0.1.4

package/dist/services/crypto.service.js

@@ -0,0 +1,126 @@
+"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.CryptoService = void 0;
+const node_crypto_1 = __importStar(require("node:crypto"));
+const keys_service_1 = require("./keys.service");
+const config_service_1 = require("../services/config.service");
+const stream_utils_1 = require("../utils/stream.utils");
+class CryptoService {
+    static instance = new CryptoService();
+    static cryptoProvider = {
+        encryptPasswordHash(password, encryptedSalt) {
+            const salt = CryptoService.instance.decryptText(encryptedSalt);
+            const hashObj = CryptoService.instance.passToHash({ password, salt });
+            return CryptoService.instance.encryptText(hashObj.hash);
+        },
+        async generateKeys(password) {
+            const { privateKeyArmoredEncrypted, publicKeyArmored, revocationCertificate } = await keys_service_1.KeysService.instance.generateNewKeysWithEncrypted(password);
+            const keys = {
+                privateKeyEncrypted: privateKeyArmoredEncrypted,
+                publicKey: publicKeyArmored,
+                revocationCertificate: revocationCertificate,
+            };
+            return keys;
+        },
+    };
+    passToHash = (passObject) => {
+        const salt = passObject.salt ? passObject.salt : node_crypto_1.default.randomBytes(128 / 8).toString('hex');
+        const hash = node_crypto_1.default
+            .pbkdf2Sync(passObject.password, Buffer.from(salt, 'hex'), 10000, 256 / 8, 'sha1')
+            .toString('hex');
+        const hashedObjetc = {
+            salt,
+            hash,
+        };
+        return hashedObjetc;
+    };
+    encryptText = (textToEncrypt) => {
+        const APP_CRYPTO_SECRET = config_service_1.ConfigService.instance.get('APP_CRYPTO_SECRET');
+        return this.encryptTextWithKey(textToEncrypt, APP_CRYPTO_SECRET);
+    };
+    decryptText = (encryptedText) => {
+        const APP_CRYPTO_SECRET = config_service_1.ConfigService.instance.get('APP_CRYPTO_SECRET');
+        return this.decryptTextWithKey(encryptedText, APP_CRYPTO_SECRET);
+    };
+    encryptTextWithKey = (textToEncrypt, secret) => {
+        const salt = node_crypto_1.default.randomBytes(8);
+        const { key, iv } = this.getKeyAndIvFrom(secret, salt);
+        const cipher = node_crypto_1.default.createCipheriv('aes-256-cbc', key, iv);
+        const encrypted = Buffer.concat([cipher.update(textToEncrypt, 'utf8'), cipher.final()]);
+        const openSSLstart = Buffer.from('Salted__');
+        return Buffer.concat([openSSLstart, salt, encrypted]).toString('hex');
+    };
+    decryptTextWithKey = (encryptedText, secret) => {
+        const cypherText = Buffer.from(encryptedText, 'hex');
+        const salt = cypherText.subarray(8, 16);
+        const { key, iv } = this.getKeyAndIvFrom(secret, salt);
+        const decipher = node_crypto_1.default.createDecipheriv('aes-256-cbc', key, iv);
+        const contentsToDecrypt = cypherText.subarray(16);
+        return Buffer.concat([decipher.update(contentsToDecrypt), decipher.final()]).toString('utf8');
+    };
+    async decryptStream(inputSlices, key, iv) {
+        const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-ctr', key, iv);
+        const encryptedStream = stream_utils_1.StreamUtils.joinReadableBinaryStreams(inputSlices);
+        let keepReading = true;
+        const decryptedStream = new ReadableStream({
+            async pull(controller) {
+                if (!keepReading)
+                    return;
+                const reader = encryptedStream.getReader();
+                const status = await reader.read();
+                if (status.done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(decipher.update(status.value));
+                }
+                reader.releaseLock();
+            },
+            cancel() {
+                keepReading = false;
+            },
+        });
+        return decryptedStream;
+    }
+    async getEncryptionTransform(key, iv) {
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-256-ctr', key, iv);
+        return cipher;
+    }
+    getKeyAndIvFrom = (secret, salt) => {
+        const TRANSFORM_ROUNDS = 3;
+        const password = Buffer.concat([Buffer.from(secret, 'binary'), salt]);
+        const md5Hashes = [];
+        let digest = password;
+        for (let i = 0; i < TRANSFORM_ROUNDS; i++) {
+            md5Hashes[i] = node_crypto_1.default.createHash('md5').update(digest).digest();
+            digest = Buffer.concat([md5Hashes[i], password]);
+        }
+        const key = Buffer.concat([md5Hashes[0], md5Hashes[1]]);
+        const iv = md5Hashes[2];
+        return { key, iv };
+    };
+}
+exports.CryptoService = CryptoService;

package/dist/services/database/drive-database-manager.service.d.ts

@@ -0,0 +1,18 @@
+import { DriveFileItem, DriveFolderItem } from '../../types/drive.types';
+import { DriveFileRepository } from './drive-file/drive-file.repository';
+import { DriveFolderRepository } from './drive-folder/drive-folder.repository';
+import { DriveFile } from './drive-file/drive-file.domain';
+import { DriveFolder } from './drive-folder/drive-folder.domain';
+export declare class DriveDatabaseManager {
+    private driveFileRepository;
+    private driveFolderRepository;
+    private static readonly sequelize;
+    constructor(driveFileRepository: DriveFileRepository, driveFolderRepository: DriveFolderRepository);
+    static readonly init: () => Promise<void>;
+    static readonly clean: () => Promise<void>;
+    findByRelativePath: (relativePath: string) => Promise<DriveFolder | DriveFile | null>;
+    createFolder: (driveFolder: DriveFolderItem) => Promise<DriveFolder>;
+    createFile: (driveFile: DriveFileItem) => Promise<DriveFile>;
+    buildRelativePathForFile: (fileName: string, parentId: number | null) => Promise<string>;
+    buildRelativePathForFolder: (folderName: string, parentId: number | null) => Promise<string>;
+}

package/dist/services/database/drive-database-manager.service.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.DriveDatabaseManager = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const config_service_1 = require("../config.service");
+const drive_file_repository_1 = require("./drive-file/drive-file.repository");
+const drive_folder_repository_1 = require("./drive-folder/drive-folder.repository");
+const drive_file_model_1 = __importDefault(require("./drive-file/drive-file.model"));
+const drive_folder_model_1 = __importDefault(require("./drive-folder/drive-folder.model"));
+class DriveDatabaseManager {
+    driveFileRepository;
+    driveFolderRepository;
+    static sequelize = new sequelize_typescript_1.Sequelize({
+        dialect: 'sqlite',
+        storage: config_service_1.ConfigService.DRIVE_SQLITE_FILE,
+        models: [drive_file_model_1.default, drive_folder_model_1.default],
+    });
+    constructor(driveFileRepository, driveFolderRepository) {
+        this.driveFileRepository = driveFileRepository;
+        this.driveFolderRepository = driveFolderRepository;
+    }
+    static init = async () => {
+        await DriveDatabaseManager.sequelize.sync();
+    };
+    static clean = async () => {
+        await drive_file_repository_1.DriveFileRepository.clean();
+        await drive_folder_repository_1.DriveFolderRepository.clean();
+    };
+    findByRelativePath = async (relativePath) => {
+        const driveFile = await this.driveFileRepository.findByRelativePath(relativePath);
+        if (driveFile)
+            return driveFile;
+        let folderRelativePath = relativePath;
+        if (!relativePath.endsWith('/'))
+            folderRelativePath = relativePath.concat('/');
+        const driveFolder = await this.driveFolderRepository.findByRelativePath(folderRelativePath);
+        if (driveFolder)
+            return driveFolder;
+        return null;
+    };
+    createFolder = async (driveFolder) => {
+        const relativePath = await this.buildRelativePathForFolder(driveFolder.name, driveFolder.parentId ?? null);
+        const existingObject = await this.driveFolderRepository.findById(driveFolder.id);
+        if (existingObject)
+            await this.driveFolderRepository.deleteById(existingObject.id);
+        return await this.driveFolderRepository.createFolder(driveFolder, relativePath);
+    };
+    createFile = async (driveFile) => {
+        const relativePath = await this.buildRelativePathForFile(driveFile.type ? `${driveFile.name}.${driveFile.type}` : driveFile.name, driveFile.folderId);
+        const existingObject = await this.driveFileRepository.findById(driveFile.id);
+        if (existingObject)
+            await this.driveFileRepository.deleteById(existingObject.id);
+        return await this.driveFileRepository.createFile(driveFile, relativePath);
+    };
+    buildRelativePathForFile = async (fileName, parentId) => {
+        const parentFolder = await this.driveFolderRepository.findById(parentId ?? -1);
+        if (!parentFolder) {
+            return webdav_utils_1.WebDavUtils.joinURL('/', fileName);
+        }
+        const parentPath = await this.buildRelativePathForFile(parentFolder.name, parentFolder.parentId);
+        return webdav_utils_1.WebDavUtils.joinURL(parentPath, fileName);
+    };
+    buildRelativePathForFolder = async (folderName, parentId) => {
+        const parentFolder = await this.driveFolderRepository.findById(parentId ?? -1);
+        if (!parentFolder) {
+            return webdav_utils_1.WebDavUtils.joinURL('/', folderName, '/');
+        }
+        const parentPath = await this.buildRelativePathForFolder(parentFolder.name, parentFolder.parentId);
+        return webdav_utils_1.WebDavUtils.joinURL(parentPath, folderName, '/');
+    };
+}
+exports.DriveDatabaseManager = DriveDatabaseManager;

package/dist/services/database/drive-file/drive-file.attributes.d.ts

@@ -0,0 +1,14 @@
+export interface DriveFileAttributes {
+    id: number;
+    name: string;
+    type?: string;
+    uuid: string;
+    fileId: string;
+    folderId: number;
+    bucket: string;
+    relativePath: string;
+    createdAt: Date;
+    updatedAt: Date;
+    size: number;
+    status: string;
+}

package/dist/services/database/drive-file/drive-file.attributes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/database/drive-file/drive-file.domain.d.ts

@@ -0,0 +1,18 @@
+import { DriveFileAttributes } from './drive-file.attributes';
+export declare class DriveFile implements DriveFileAttributes {
+    id: number;
+    name: string;
+    type?: string;
+    uuid: string;
+    fileId: string;
+    folderId: number;
+    bucket: string;
+    relativePath: string;
+    createdAt: Date;
+    updatedAt: Date;
+    size: number;
+    status: string;
+    constructor({ id, name, type, uuid, fileId, folderId, bucket, relativePath, createdAt, updatedAt, size, status, }: DriveFileAttributes);
+    static build(file: DriveFileAttributes): DriveFile;
+    toJSON(): DriveFileAttributes;
+}

package/dist/services/database/drive-file/drive-file.domain.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFile = void 0;
+class DriveFile {
+    id;
+    name;
+    type;
+    uuid;
+    fileId;
+    folderId;
+    bucket;
+    relativePath;
+    createdAt;
+    updatedAt;
+    size;
+    status;
+    constructor({ id, name, type, uuid, fileId, folderId, bucket, relativePath, createdAt, updatedAt, size, status, }) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+        this.uuid = uuid;
+        this.fileId = fileId;
+        this.folderId = folderId;
+        this.bucket = bucket;
+        this.relativePath = relativePath;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+        this.size = size;
+        this.status = status;
+    }
+    static build(file) {
+        return new DriveFile(file);
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            uuid: this.uuid,
+            fileId: this.fileId,
+            folderId: this.folderId,
+            bucket: this.bucket,
+            relativePath: this.relativePath,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            size: this.size,
+            status: this.status,
+        };
+    }
+}
+exports.DriveFile = DriveFile;

package/dist/services/database/drive-file/drive-file.model.d.ts

@@ -0,0 +1,17 @@
+import { Model } from 'sequelize-typescript';
+import { DriveFileAttributes } from './drive-file.attributes';
+export declare class DriveFileModel extends Model implements DriveFileAttributes {
+    id: number;
+    name: string;
+    type?: string;
+    uuid: string;
+    fileId: string;
+    folderId: number;
+    bucket: string;
+    relativePath: string;
+    size: number;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export default DriveFileModel;

package/dist/services/database/drive-file/drive-file.model.js

@@ -0,0 +1,82 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFileModel = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+let DriveFileModel = class DriveFileModel extends sequelize_typescript_1.Model {
+};
+exports.DriveFileModel = DriveFileModel;
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    sequelize_typescript_1.AutoIncrement,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
+    __metadata("design:type", Number)
+], DriveFileModel.prototype, "id", void 0);
+__decorate([
+    sequelize_typescript_1.Index,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "name", void 0);
+__decorate([
+    sequelize_typescript_1.AllowNull,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING(24)),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "type", void 0);
+__decorate([
+    sequelize_typescript_1.Unique,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.UUIDV4),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "uuid", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING(24)),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "fileId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
+    __metadata("design:type", Number)
+], DriveFileModel.prototype, "folderId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING(24)),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "bucket", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.TEXT),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "relativePath", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.BIGINT),
+    __metadata("design:type", Number)
+], DriveFileModel.prototype, "size", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.ENUM,
+        values: Object.values(types_1.FileStatus),
+        defaultValue: types_1.FileStatus.EXISTS,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "status", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.DATE),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.DATE),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "updatedAt", void 0);
+exports.DriveFileModel = DriveFileModel = __decorate([
+    (0, sequelize_typescript_1.Table)({
+        underscored: true,
+        tableName: 'files',
+    })
+], DriveFileModel);
+exports.default = DriveFileModel;

package/dist/services/database/drive-file/drive-file.repository.d.ts

@@ -0,0 +1,11 @@
+import { DriveFileItem } from '../../../types/drive.types';
+import { DriveFileModel } from './drive-file.model';
+import { DriveFile } from './drive-file.domain';
+export declare class DriveFileRepository {
+    findByRelativePath: (relativePath: DriveFile['relativePath']) => Promise<DriveFile | null>;
+    findById: (id: DriveFile['id']) => Promise<DriveFile | null>;
+    deleteById: (id: DriveFile['id']) => Promise<number>;
+    createFile: (driveFileItem: DriveFileItem, relativePath: string) => Promise<DriveFile>;
+    toDomain: (model: DriveFileModel) => DriveFile;
+    static readonly clean: () => Promise<void>;
+}

package/dist/services/database/drive-file/drive-file.repository.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFileRepository = void 0;
+const drive_file_model_1 = require("./drive-file.model");
+const drive_file_domain_1 = require("./drive-file.domain");
+class DriveFileRepository {
+    findByRelativePath = async (relativePath) => {
+        const file = await drive_file_model_1.DriveFileModel.findOne({
+            where: {
+                relativePath,
+            },
+        });
+        return file ? this.toDomain(file) : null;
+    };
+    findById = async (id) => {
+        const file = await drive_file_model_1.DriveFileModel.findByPk(id);
+        return file ? this.toDomain(file) : null;
+    };
+    deleteById = (id) => {
+        return drive_file_model_1.DriveFileModel.destroy({ where: { id } });
+    };
+    createFile = async (driveFileItem, relativePath) => {
+        const driveFile = drive_file_domain_1.DriveFile.build({
+            ...driveFileItem,
+            relativePath,
+        });
+        const newFile = await drive_file_model_1.DriveFileModel.create({ ...driveFile.toJSON() });
+        return this.toDomain(newFile);
+    };
+    toDomain = (model) => {
+        const driveFile = drive_file_domain_1.DriveFile.build({
+            ...model.toJSON(),
+        });
+        return driveFile;
+    };
+    static clean = () => {
+        return drive_file_model_1.DriveFileModel.truncate();
+    };
+}
+exports.DriveFileRepository = DriveFileRepository;

package/dist/services/database/drive-folder/drive-folder.attributes.d.ts

@@ -0,0 +1,9 @@
+export interface DriveFolderAttributes {
+    id: number;
+    name: string;
+    uuid: string;
+    relativePath: string;
+    parentId: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/services/database/drive-folder/drive-folder.attributes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/database/drive-folder/drive-folder.domain.d.ts

@@ -0,0 +1,13 @@
+import { DriveFolderAttributes } from './drive-folder.attributes';
+export declare class DriveFolder implements DriveFolderAttributes {
+    id: number;
+    name: string;
+    uuid: string;
+    relativePath: string;
+    parentId: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt }: DriveFolderAttributes);
+    static build(folder: DriveFolderAttributes): DriveFolder;
+    toJSON(): DriveFolderAttributes;
+}

package/dist/services/database/drive-folder/drive-folder.domain.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFolder = void 0;
+class DriveFolder {
+    id;
+    name;
+    uuid;
+    relativePath;
+    parentId;
+    createdAt;
+    updatedAt;
+    constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt }) {
+        this.id = id;
+        this.name = name;
+        this.uuid = uuid;
+        this.relativePath = relativePath;
+        this.parentId = parentId;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    static build(folder) {
+        return new DriveFolder(folder);
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            uuid: this.uuid,
+            relativePath: this.relativePath,
+            parentId: this.parentId,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+        };
+    }
+}
+exports.DriveFolder = DriveFolder;

package/dist/services/database/drive-folder/drive-folder.model.d.ts

@@ -0,0 +1,12 @@
+import { Model } from 'sequelize-typescript';
+import { DriveFolderAttributes } from './drive-folder.attributes';
+export declare class DriveFolderModel extends Model implements DriveFolderAttributes {
+    id: number;
+    name: string;
+    uuid: string;
+    relativePath: string;
+    parentId: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export default DriveFolderModel;

package/dist/services/database/drive-folder/drive-folder.model.js

@@ -0,0 +1,56 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFolderModel = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+let DriveFolderModel = class DriveFolderModel extends sequelize_typescript_1.Model {
+};
+exports.DriveFolderModel = DriveFolderModel;
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    sequelize_typescript_1.AutoIncrement,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
+    __metadata("design:type", Number)
+], DriveFolderModel.prototype, "id", void 0);
+__decorate([
+    sequelize_typescript_1.Index,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "name", void 0);
+__decorate([
+    sequelize_typescript_1.Unique,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.UUIDV4),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "uuid", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.TEXT),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "relativePath", void 0);
+__decorate([
+    sequelize_typescript_1.AllowNull,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
+    __metadata("design:type", Object)
+], DriveFolderModel.prototype, "parentId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.DATE),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.DATE),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "updatedAt", void 0);
+exports.DriveFolderModel = DriveFolderModel = __decorate([
+    (0, sequelize_typescript_1.Table)({
+        underscored: true,
+        tableName: 'folders',
+    })
+], DriveFolderModel);
+exports.default = DriveFolderModel;

package/dist/services/database/drive-folder/drive-folder.repository.d.ts

@@ -0,0 +1,11 @@
+import { DriveFolderItem } from '../../../types/drive.types';
+import { DriveFolder } from './drive-folder.domain';
+import { DriveFolderModel } from './drive-folder.model';
+export declare class DriveFolderRepository {
+    findByRelativePath: (relativePath: DriveFolder['relativePath']) => Promise<DriveFolder | null>;
+    findById: (id: DriveFolder['id']) => Promise<DriveFolder | null>;
+    deleteById: (id: DriveFolder['id']) => Promise<number>;
+    createFolder: (driveFolderItem: DriveFolderItem, relativePath: string) => Promise<DriveFolder>;
+    toDomain: (model: DriveFolderModel) => DriveFolder;
+    static readonly clean: () => Promise<void>;
+}

package/dist/services/database/drive-folder/drive-folder.repository.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFolderRepository = void 0;
+const drive_folder_domain_1 = require("./drive-folder.domain");
+const drive_folder_model_1 = require("./drive-folder.model");
+class DriveFolderRepository {
+    findByRelativePath = async (relativePath) => {
+        const folder = await drive_folder_model_1.DriveFolderModel.findOne({
+            where: {
+                relativePath,
+            },
+        });
+        return folder ? this.toDomain(folder) : null;
+    };
+    findById = async (id) => {
+        const folder = await drive_folder_model_1.DriveFolderModel.findByPk(id);
+        return folder ? this.toDomain(folder) : null;
+    };
+    deleteById = (id) => {
+        return drive_folder_model_1.DriveFolderModel.destroy({ where: { id } });
+    };
+    createFolder = async (driveFolderItem, relativePath) => {
+        const driveFolder = drive_folder_domain_1.DriveFolder.build({
+            ...driveFolderItem,
+            relativePath,
+        });
+        const newFolder = await drive_folder_model_1.DriveFolderModel.create({ ...driveFolder.toJSON() });
+        return this.toDomain(newFolder);
+    };
+    toDomain = (model) => {
+        const driveFolder = drive_folder_domain_1.DriveFolder.build({
+            ...model.toJSON(),
+        });
+        return driveFolder;
+    };
+    static clean = () => {
+        return drive_folder_model_1.DriveFolderModel.truncate();
+    };
+}
+exports.DriveFolderRepository = DriveFolderRepository;