@internxt/cli 1.6.1 → 1.6.3

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

@@ -1,22 +1,19 @@
 import { DriveFileItem } from '../../../types/drive.types';
 import { DriveFileAttributes } from './drive-file.attributes';
 export declare class DriveFile implements DriveFileAttributes {
-    id: number;
     name: string;
-    type?: string;
+    type: string | null;
     uuid: string;
-    fileId: string;
-    folderId: number;
+    fileId: string | null;
     folderUuid: string;
     bucket: string;
-    relativePath: string;
     createdAt: Date;
     updatedAt: Date;
     size: number;
     status: 'EXISTS' | 'TRASHED' | 'DELETED';
     creationTime: Date;
     modificationTime: Date;
-    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, creationTime, modificationTime, }: DriveFileAttributes);
+    constructor({ name, type, uuid, fileId, folderUuid, bucket, createdAt, updatedAt, size, status, creationTime, modificationTime, }: DriveFileAttributes);
     static build(file: DriveFileAttributes): DriveFile;
     toJSON(): DriveFileAttributes;
     toItem(): DriveFileItem;

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

@@ -2,31 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFile = void 0;
 class DriveFile {
-    id;
     name;
     type;
     uuid;
     fileId;
-    folderId;
     folderUuid;
     bucket;
-    relativePath;
     createdAt;
     updatedAt;
     size;
     status;
     creationTime;
     modificationTime;
-    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, creationTime, modificationTime, }) {
-        this.id = id;
+    constructor({ name, type, uuid, fileId, folderUuid, bucket, createdAt, updatedAt, size, status, creationTime, modificationTime, }) {
         this.name = name;
         this.type = type;
         this.uuid = uuid;
         this.fileId = fileId;
-        this.folderId = folderId;
         this.folderUuid = folderUuid;
         this.bucket = bucket;
-        this.relativePath = relativePath;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
         this.size = size;
@@ -39,15 +33,12 @@ class DriveFile {
     }
     toJSON() {
         return {
-            id: this.id,
             name: this.name,
             type: this.type,
             uuid: this.uuid,
             fileId: this.fileId,
-            folderId: this.folderId,
             folderUuid: this.folderUuid,
             bucket: this.bucket,
-            relativePath: this.relativePath,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
             size: this.size,
@@ -59,12 +50,10 @@ class DriveFile {
     toItem() {
         return {
             itemType: 'file',
-            id: this.id,
             name: this.name,
             type: this.type,
             uuid: this.uuid,
             fileId: this.fileId,
-            folderId: this.folderId,
             folderUuid: this.folderUuid,
             bucket: this.bucket,
             createdAt: this.createdAt,

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

@@ -0,0 +1,15 @@
+import { DriveFileAttributes } from './drive-file.attributes';
+export declare class DriveFileModel implements DriveFileAttributes {
+    uuid: string;
+    name: string;
+    type: string | null;
+    fileId: string | null;
+    folderUuid: string;
+    bucket: string;
+    createdAt: Date;
+    updatedAt: Date;
+    size: number;
+    status: 'EXISTS' | 'TRASHED' | 'DELETED';
+    creationTime: Date;
+    modificationTime: Date;
+}

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

@@ -0,0 +1,67 @@
+"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 typeorm_1 = require("typeorm");
+let DriveFileModel = class DriveFileModel {
+};
+exports.DriveFileModel = DriveFileModel;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "uuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFileModel.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFileModel.prototype, "fileId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "folderUuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "bucket", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'bigint' }),
+    __metadata("design:type", Number)
+], DriveFileModel.prototype, "size", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "creationTime", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "modificationTime", void 0);
+exports.DriveFileModel = DriveFileModel = __decorate([
+    (0, typeorm_1.Entity)('drive_file')
+], DriveFileModel);

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

@@ -0,0 +1,11 @@
+import { DriveFile } from './drive-file.domain';
+import { DriveFileModel } from './drive-file.model';
+export declare class FileRepository {
+    static readonly instance: FileRepository;
+    private readonly fileRepository;
+    createOrUpdate: (files: DriveFileModel[]) => Promise<DriveFile[] | undefined>;
+    updateByUuid: (uuid: string, update: Partial<DriveFileModel>) => Promise<import("typeorm").UpdateResult | undefined>;
+    delete: (uuids: string[]) => Promise<import("typeorm").DeleteResult | undefined>;
+    deleteByParentUuid: (parentUuid: string) => Promise<import("typeorm").DeleteResult | undefined>;
+    getByParentUuidNameAndType: (parentUuid: string, name: string, type: string | null) => Promise<DriveFile | undefined>;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRepository = void 0;
+const typeorm_1 = require("typeorm");
+const database_utils_1 = require("../../../utils/database.utils");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const database_service_1 = require("../database.service");
+const drive_file_domain_1 = require("./drive-file.domain");
+const drive_file_model_1 = require("./drive-file.model");
+class FileRepository {
+    static instance = new FileRepository();
+    fileRepository = database_service_1.DatabaseService.instance.dataSource.getRepository(drive_file_model_1.DriveFileModel);
+    createOrUpdate = async (files) => {
+        try {
+            for (let i = 0; i < files.length; i += database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE) {
+                const chunk = files.slice(i, i + database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE);
+                await this.fileRepository.upsert(chunk, { conflictPaths: ['uuid'] });
+            }
+            return files.map((file) => drive_file_domain_1.DriveFile.build(file));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { createOrUpdate: files });
+        }
+    };
+    updateByUuid = async (uuid, update) => {
+        try {
+            return await this.fileRepository.update({ uuid }, update);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { updateByUuid: uuid });
+        }
+    };
+    delete = async (uuids) => {
+        try {
+            return await this.fileRepository.delete(uuids);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { delete: uuids });
+        }
+    };
+    deleteByParentUuid = async (parentUuid) => {
+        try {
+            return await this.fileRepository.delete({ folderUuid: parentUuid });
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { deleteByParentUuid: parentUuid });
+        }
+    };
+    getByParentUuidNameAndType = async (parentUuid, name, type) => {
+        try {
+            const typeCondition = type ?? (0, typeorm_1.IsNull)();
+            const file = await this.fileRepository.findOneBy({ folderUuid: parentUuid, name, type: typeCondition });
+            if (!file) {
+                return;
+            }
+            return drive_file_domain_1.DriveFile.build(file);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByParentuuidAndName: { parentUuid, name, type } });
+        }
+    };
+}
+exports.FileRepository = FileRepository;

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

@@ -1,11 +1,10 @@
 export interface DriveFolderAttributes {
-    id: number;
-    name: string;
     uuid: string;
+    name: string;
     status: 'EXISTS' | 'TRASHED';
-    relativePath: string;
-    parentId: number | null;
     parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
 }

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

@@ -1,16 +1,15 @@
 import { DriveFolderItem } from '../../../types/drive.types';
 import { DriveFolderAttributes } from './drive-folder.attributes';
 export declare class DriveFolder implements DriveFolderAttributes {
-    id: number;
     name: string;
     uuid: string;
-    relativePath: string;
-    parentId: number | null;
     parentUuid: string | null;
+    status: DriveFolderAttributes['status'];
     createdAt: Date;
     updatedAt: Date;
-    status: DriveFolderAttributes['status'];
-    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }: DriveFolderAttributes);
+    creationTime: Date;
+    modificationTime: Date;
+    constructor({ name, uuid, parentUuid, createdAt, updatedAt, status, creationTime, modificationTime, }: DriveFolderAttributes);
     static build(folder: DriveFolderAttributes): DriveFolder;
     toJSON(): DriveFolderAttributes;
     toItem(): DriveFolderItem;

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

@@ -2,54 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFolder = void 0;
 class DriveFolder {
-    id;
     name;
     uuid;
-    relativePath;
-    parentId;
     parentUuid;
+    status;
     createdAt;
     updatedAt;
-    status;
-    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }) {
-        this.id = id;
+    creationTime;
+    modificationTime;
+    constructor({ name, uuid, parentUuid, createdAt, updatedAt, status, creationTime, modificationTime, }) {
         this.name = name;
         this.uuid = uuid;
-        this.relativePath = relativePath;
-        this.parentId = parentId;
         this.parentUuid = parentUuid;
+        this.status = status;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
-        this.status = status;
+        this.creationTime = creationTime;
+        this.modificationTime = modificationTime;
     }
     static build(folder) {
         return new DriveFolder(folder);
     }
     toJSON() {
         return {
-            id: this.id,
             name: this.name,
             uuid: this.uuid,
             status: this.status,
-            relativePath: this.relativePath,
-            parentId: this.parentId,
             parentUuid: this.parentUuid,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
         };
     }
     toItem() {
         return {
             itemType: 'folder',
-            id: this.id,
             name: this.name,
             uuid: this.uuid,
             status: this.status,
-            parentId: this.parentId,
             parentUuid: this.parentUuid,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
-            encryptedName: '',
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
             bucket: null,
         };
     }

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

@@ -0,0 +1,11 @@
+import { DriveFolderAttributes } from './drive-folder.attributes';
+export declare class DriveFolderModel implements DriveFolderAttributes {
+    uuid: string;
+    name: string;
+    status: 'EXISTS' | 'TRASHED';
+    parentUuid: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
+}

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

@@ -0,0 +1,51 @@
+"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 typeorm_1 = require("typeorm");
+let DriveFolderModel = class DriveFolderModel {
+};
+exports.DriveFolderModel = DriveFolderModel;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "uuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFolderModel.prototype, "parentUuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "creationTime", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "modificationTime", void 0);
+exports.DriveFolderModel = DriveFolderModel = __decorate([
+    (0, typeorm_1.Entity)('drive_folder')
+], DriveFolderModel);

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

@@ -0,0 +1,13 @@
+import { DriveFolder } from './drive-folder.domain';
+import { DriveFolderModel } from './drive-folder.model';
+export declare class FolderRepository {
+    static readonly instance: FolderRepository;
+    private readonly folderRepository;
+    getByUuid: (uuid: string) => Promise<DriveFolder | undefined>;
+    getAllByParentUuid: (parentUuid?: string) => Promise<DriveFolder[] | undefined>;
+    getByParentUuidAndName: (parentUuid: string, name: string) => Promise<DriveFolder | undefined>;
+    getByPath: (path: string, parentUuid: string) => Promise<DriveFolder | undefined>;
+    createOrUpdate: (files: DriveFolderModel[]) => Promise<DriveFolder[] | undefined>;
+    updateByUuid: (uuid: string, update: Partial<DriveFolderModel>) => Promise<import("typeorm").UpdateResult | undefined>;
+    delete: (uuids: string[]) => Promise<import("typeorm").DeleteResult | undefined>;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderRepository = void 0;
+const errors_utils_1 = require("../../../utils/errors.utils");
+const database_service_1 = require("../database.service");
+const drive_folder_domain_1 = require("./drive-folder.domain");
+const drive_folder_model_1 = require("./drive-folder.model");
+const database_utils_1 = require("../../../utils/database.utils");
+class FolderRepository {
+    static instance = new FolderRepository();
+    folderRepository = database_service_1.DatabaseService.instance.dataSource.getRepository(drive_folder_model_1.DriveFolderModel);
+    getByUuid = async (uuid) => {
+        try {
+            const folder = await this.folderRepository.findOneBy({ uuid });
+            if (!folder) {
+                return;
+            }
+            return drive_folder_domain_1.DriveFolder.build(folder);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByUuid: uuid });
+        }
+    };
+    getAllByParentUuid = async (parentUuid) => {
+        try {
+            const folders = await this.folderRepository.findBy({ parentUuid });
+            if (!folders) {
+                return;
+            }
+            return folders.map((folder) => drive_folder_domain_1.DriveFolder.build(folder));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getAllByParentUuid: parentUuid });
+        }
+    };
+    getByParentUuidAndName = async (parentUuid, name) => {
+        try {
+            const folder = await this.folderRepository.findOneBy({ parentUuid, name });
+            if (!folder) {
+                return;
+            }
+            return drive_folder_domain_1.DriveFolder.build(folder);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByParentuuidAndName: { parentUuid, name } });
+        }
+    };
+    getByPath = async (path, parentUuid) => {
+        try {
+            const onFound = async (uuid) => {
+                const folder = await this.folderRepository.findOneBy({ uuid });
+                if (!folder) {
+                    return;
+                }
+                return drive_folder_domain_1.DriveFolder.build(folder);
+            };
+            return database_utils_1.DatabaseUtils.getFolderByPathGeneric({
+                path,
+                parentUuid,
+                onFound,
+                getByParentAndName: this.getByParentUuidAndName.bind(this),
+            });
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByPath: path });
+        }
+    };
+    createOrUpdate = async (files) => {
+        if (files.length === 0)
+            return;
+        try {
+            for (let i = 0; i < files.length; i += database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE) {
+                const chunk = files.slice(i, i + database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE);
+                await this.folderRepository.upsert(chunk, { conflictPaths: ['uuid'] });
+            }
+            return files.map((file) => drive_folder_domain_1.DriveFolder.build(file));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { createOrUpdate: files });
+        }
+    };
+    updateByUuid = async (uuid, update) => {
+        try {
+            return await this.folderRepository.update({ uuid }, update);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { updateByUuid: uuid });
+        }
+    };
+    delete = async (uuids) => {
+        try {
+            return await this.folderRepository.delete(uuids);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { delete: uuids });
+        }
+    };
+}
+exports.FolderRepository = FolderRepository;

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

@@ -3,12 +3,14 @@ import { DriveFileItem } from '../../types/drive.types';
 export declare class DriveFileService {
     static readonly instance: DriveFileService;
     createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
+    private createDriveFileEntry;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
     moveFile: (uuid: string, payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
     renameFile: (fileUuid: string, payload: {
         plainName?: string;
         type?: string | null;
     }) => Promise<void>;
+    getByParentUuidAndName: (parentUuid: string, name: string, type: string | null) => Promise<DriveFileItem>;
     getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
     createThumbnail: (payload: StorageTypes.CreateThumbnailEntryPayload) => Promise<StorageTypes.Thumbnail>;
 }