@drax/media-back 2.11.0 → 3.1.0

package/dist/controllers/FileController.js

@@ -0,0 +1,38 @@
+import FileServiceFactory from "../factory/services/FileServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import FilePermissions from "../permissions/FilePermissions.js";
+import { StoreManager } from "@drax/common-back";
+class FileController extends AbstractFastifyController {
+    constructor() {
+        super(FileServiceFactory.instance, FilePermissions);
+        this.tenantField = "tenant";
+        this.userField = "createdBy.id";
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+    async preUpdate(request, payload) {
+        delete payload.relativePath;
+        delete payload.absolutePath;
+        delete payload.filename;
+        payload.updatedBy = {
+            id: request.rbac.userId,
+            username: request.rbac.username,
+        };
+        return payload;
+    }
+    async postDelete(request, item) {
+        try {
+            await StoreManager.deleteFilepath(item.relativePath);
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return item;
+    }
+}
+export default FileController;
+export { FileController };

package/dist/controllers/MediaController.js

@@ -1,6 +1,8 @@
 import { CommonController, StoreManager, DraxConfig, CommonConfig, } from "@drax/common-back";
 import { join } from "path";
 import { MediaPermissions } from "../permissions/MediaPermissions.js";
+import { FileServiceFactory } from "../factory/services/FileServiceFactory.js";
+import path from 'node:path';
 const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
 const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : '';
 class MediaController extends CommonController {
@@ -17,6 +19,10 @@ class MediaController extends CommonController {
     async uploadFile(request, reply) {
         try {
             request.rbac.assertPermission(MediaPermissions.UploadFile);
+            const createdBy = {
+                id: request.rbac.userId,
+                username: request.rbac.username,
+            };
             const dir = request.params.dir;
             if (!this.validateDir(dir)) {
                 reply.statusCode = 400;
@@ -34,13 +40,42 @@ class MediaController extends CommonController {
             const destinationPath = join(BASE_FILE_DIR, dir, year, month);
             const storedFile = await StoreManager.saveFile(file, destinationPath);
             const urlFile = `${BASE_URL}/api/file/${dir}/${year}/${month}/${storedFile.filename}`;
-            return {
+            const relativePath = storedFile.path;
+            const absolutePath = path.resolve(process.cwd(), relativePath);
+            const extension = StoreManager.getExtension(storedFile.filename);
+            const fileService = FileServiceFactory.instance;
+            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true;
+            if (FILE_METADATA === true) {
+                try {
+                    await fileService.registerUploadedFile({
+                        filename: storedFile.filename,
+                        relativePath: relativePath,
+                        absolutePath: absolutePath,
+                        size: storedFile.size,
+                        mimetype: storedFile.mimetype || data.mimetype,
+                        encoding: storedFile.encoding || data.encoding || '',
+                        extension,
+                        type: storedFile.mimetype?.split('/')[0] || '',
+                        lastAccess: new Date(),
+                        ttlSeconds: 0,
+                        hits: 0,
+                        url: urlFile,
+                        createdBy,
+                    });
+                }
+                catch (e) {
+                    await StoreManager.deleteFile(destinationPath, storedFile.filename).catch(() => undefined);
+                    throw e;
+                }
+            }
+            let theFile = {
                 filename: storedFile.filename,
                 filepath: storedFile.path,
                 size: storedFile.size,
                 mimetype: storedFile.mimetype,
                 url: urlFile,
             };
+            return theFile;
         }
         catch (e) {
             this.handleError(e, reply);
@@ -70,6 +105,12 @@ class MediaController extends CommonController {
             }
             const fileDir = join(BASE_FILE_DIR, dir, year, month);
             //console.log("FILE_DIR: ", fileDir, " FILENAME:", filename)
+            //Agregar hit al archivo
+            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true;
+            if (FILE_METADATA === true) {
+                const fileService = FileServiceFactory.instance;
+                await fileService.registerDownloadHit(join(fileDir, filename));
+            }
             return reply.sendFile(filename, fileDir);
         }
         catch (e) {

package/dist/factory/services/FileServiceFactory.js

@@ -0,0 +1,30 @@
+import FileMongoRepository from '../../repository/mongo/FileMongoRepository.js';
+import FileSqliteRepository from '../../repository/sqlite/FileSqliteRepository.js';
+import { FileService } from '../../services/FileService.js';
+import { FileBaseSchema, FileSchema } from "../../schemas/FileSchema.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+class FileServiceFactory {
+    static get instance() {
+        if (!FileServiceFactory.service) {
+            let repository;
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new FileMongoRepository();
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                    repository = new FileSqliteRepository(dbFile, false);
+                    repository.build();
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            const baseSchema = FileBaseSchema;
+            const fullSchema = FileSchema;
+            FileServiceFactory.service = new FileService(repository, baseSchema, fullSchema);
+        }
+        return FileServiceFactory.service;
+    }
+}
+export default FileServiceFactory;
+export { FileServiceFactory };

package/dist/index.js

@@ -1,7 +1,18 @@
 import { MediaRoutes } from "./routes/MediaRoutes.js";
 import { MediaPermissions } from "./permissions/MediaPermissions.js";
+import { FileRoutes } from "./routes/FileRoutes.js";
+import { FilePermissions } from "./permissions/FilePermissions.js";
+import FileSchema from "./schemas/FileSchema.js";
+import FileModel from "./models/FileModel.js";
+import FileMongoRepository from "./repository/mongo/FileMongoRepository.js";
+import FileSqliteRepository from "./repository/sqlite/FileSqliteRepository.js";
+import FileService from "./services/FileService.js";
+import FileServiceFactory from "./factory/services/FileServiceFactory.js";
+import FileController from "./controllers/FileController.js";
 export { 
 //Routes
-MediaRoutes, 
+MediaRoutes, FileRoutes, 
 //Permissions
-MediaPermissions, };
+MediaPermissions, FilePermissions, 
+//File
+FileSchema, FileModel, FileMongoRepository, FileSqliteRepository, FileService, FileServiceFactory, FileController };

package/dist/interfaces/IFile.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IFileRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/FileModel.js

@@ -0,0 +1,49 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const FileSchema = new mongoose.Schema({
+    filename: { type: String, required: true, index: false, unique: false },
+    relativePath: { type: String, required: true, index: true, unique: false },
+    absolutePath: { type: String, required: true, index: false, unique: false },
+    url: { type: String, required: true, index: false, unique: false },
+    description: { type: String, required: false, index: false, unique: false },
+    tags: [{ type: String, required: false, index: false, unique: false }],
+    mimetype: { type: String, required: true, index: false, unique: false },
+    encoding: { type: String, required: false, index: false, unique: false },
+    extension: { type: String, required: false, index: false, unique: false },
+    size: { type: Number, required: true, index: false, unique: false },
+    type: { type: String, required: false, index: false, unique: false },
+    lastAccess: { type: Date, required: false, index: false, unique: false },
+    createdBy: {
+        id: { type: mongoose.Schema.Types.ObjectId, required: false, index: false, unique: false },
+        username: { type: String, required: false, index: false, unique: false }
+    },
+    updatedBy: {
+        id: { type: mongoose.Schema.Types.ObjectId, required: false, index: false, unique: false },
+        username: { type: String, required: false, index: false, unique: false }
+    },
+    createdFor: { type: String, required: false, index: false, unique: false },
+    ttlSeconds: { type: Number, required: false, index: false, unique: false },
+    expiresAt: { type: Date, required: false, index: false, unique: false },
+    isPublic: { type: Boolean, required: false, index: false, unique: false },
+    hits: { type: Number, required: false, index: false, unique: false },
+    tenant: { type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: false, unique: false },
+}, { timestamps: true });
+FileSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+FileSchema.plugin(mongoosePaginate);
+FileSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+FileSchema.set('toJSON', { getters: true, virtuals: true });
+FileSchema.set('toObject', { getters: true, virtuals: true });
+FileSchema.pre("validate", function (next) {
+    if (this.ttlSeconds && !this.expiresAt) {
+        this.expiresAt = new Date(Date.now() + this.ttlSeconds * 1000);
+    }
+    next();
+});
+const MODEL_NAME = 'File';
+const COLLECTION_NAME = 'File';
+const FileModel = mongoose.model(MODEL_NAME, FileSchema, COLLECTION_NAME);
+export { FileSchema, FileModel };
+export default FileModel;

package/dist/permissions/FilePermissions.js

@@ -0,0 +1,13 @@
+var FilePermissions;
+(function (FilePermissions) {
+    FilePermissions["Create"] = "file:create";
+    FilePermissions["Update"] = "file:update";
+    FilePermissions["Delete"] = "file:delete";
+    FilePermissions["View"] = "file:view";
+    FilePermissions["ViewAll"] = "file:viewAll";
+    FilePermissions["UpdateAll"] = "file:updateAll";
+    FilePermissions["DeleteAll"] = "file:deleteAll";
+    FilePermissions["Manage"] = "file:manage";
+})(FilePermissions || (FilePermissions = {}));
+export { FilePermissions };
+export default FilePermissions;

package/dist/repository/mongo/FileMongoRepository.js

@@ -0,0 +1,13 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { FileModel } from "../../models/FileModel.js";
+class FileMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = FileModel;
+        this._searchFields = ['filename', 'url', 'description', 'tags', 'mimetype', 'extension', 'type'];
+        this._populateFields = ['tenant'];
+        this._lean = true;
+    }
+}
+export default FileMongoRepository;
+export { FileMongoRepository };

package/dist/repository/sqlite/FileSqliteRepository.js

@@ -0,0 +1,37 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class FileSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'File';
+        this.searchFields = ['filename', 'relativePath', 'absolutePath', 'url', 'description', 'tags', 'mimetype', 'extension', 'type'];
+        this.booleanFields = ['isPublic'];
+        this.identifier = '_id';
+        this.populateFields = [];
+        this.verbose = false;
+        this.tableFields = [
+            { name: "filename", type: "TEXT", unique: undefined, primary: false },
+            { name: "relativePath", type: "TEXT", unique: undefined, primary: false },
+            { name: "absolutePath", type: "TEXT", unique: undefined, primary: false },
+            { name: "url", type: "TEXT", unique: undefined, primary: false },
+            { name: "description", type: "TEXT", unique: undefined, primary: false },
+            { name: "tags", type: "TEXT", unique: undefined, primary: false },
+            { name: "mimetype", type: "TEXT", unique: undefined, primary: false },
+            { name: "encoding", type: "TEXT", unique: undefined, primary: false },
+            { name: "extension", type: "TEXT", unique: undefined, primary: false },
+            { name: "size", type: "REAL", unique: undefined, primary: false },
+            { name: "type", type: "TEXT", unique: undefined, primary: false },
+            { name: "lastAccess", type: "TEXT", unique: undefined, primary: false },
+            { name: "createdAt", type: "TEXT", unique: undefined, primary: false },
+            { name: "updatedAt", type: "TEXT", unique: undefined, primary: false },
+            { name: "createdBy", type: "TEXT", unique: undefined, primary: false },
+            { name: "updatedBy", type: "TEXT", unique: undefined, primary: false },
+            { name: "createdFor", type: "TEXT", unique: undefined, primary: false },
+            { name: "ttlSeconds", type: "REAL", unique: undefined, primary: false },
+            { name: "expiresAt", type: "TEXT", unique: undefined, primary: false },
+            { name: "isPublic", type: "TEXT", unique: undefined, primary: false },
+            { name: "hits", type: "REAL", unique: undefined, primary: false }
+        ];
+    }
+}
+export default FileSqliteRepository;
+export { FileSqliteRepository };

package/dist/routes/FileRoutes.js

@@ -0,0 +1,20 @@
+import FileController from "../controllers/FileController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { FileSchema, FileBaseSchema } from '../schemas/FileSchema.js';
+async function FileRoutes(fastify, options) {
+    const controller = new FileController();
+    const schemas = new CrudSchemaBuilder(FileSchema, FileBaseSchema, FileBaseSchema, 'File', 'openapi-3.0', ['media']);
+    fastify.get('/api/file', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/file/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/file/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    fastify.get('/api/file/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/file/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/file/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.post('/api/file', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/file/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.patch('/api/file/:id', { schema: schemas.updateSchema }, (req, rep) => controller.updatePartial(req, rep));
+    fastify.delete('/api/file/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    fastify.get('/api/file/export', (req, rep) => controller.export(req, rep));
+}
+export default FileRoutes;
+export { FileRoutes };

package/dist/schemas/FileSchema.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+const FileBaseSchema = z.object({
+    filename: z.string().min(1, 'validation.required'),
+    relativePath: z.string().min(1, 'validation.required'),
+    absolutePath: z.string().min(1, 'validation.required'),
+    url: z.string().min(1, 'validation.required'),
+    description: z.string().default('').nullish(),
+    tags: z.array(z.string()).optional().default([]),
+    mimetype: z.string().nullish(),
+    encoding: z.string().nullish(),
+    extension: z.string().nullish(),
+    size: z.number().min(0, 'validation.required').nullish(),
+    type: z.string().nullish(),
+    lastAccess: z.coerce.date({ error: "validation.date" }).nullish(),
+    createdFor: z.string().nullish(),
+    ttlSeconds: z.number().default(0).nullish(),
+    expiresAt: z.coerce.date().nullish(),
+    isPublic: z.boolean().nullish(),
+    hits: z.number().default(0),
+    createdBy: z.object({
+        id: z.string().nullish(),
+        username: z.string().nullish()
+    }).nullish(),
+    updatedBy: z.object({
+        id: z.string().nullish(),
+        username: z.string().nullish()
+    }).nullish(),
+    tenant: z.coerce.string().nullish(),
+});
+const FileSchema = FileBaseSchema
+    .omit({ absolutePath: true })
+    .extend({
+    _id: z.coerce.string(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    expiresAt: z.coerce.date().nullish(),
+    createdBy: z.object({
+        id: z.coerce.string().nullish(),
+        username: z.string().nullish()
+    }).nullish(),
+    updatedBy: z.object({
+        id: z.coerce.string().nullish(),
+        username: z.string().nullish()
+    }).nullish(),
+    tenant: z.object({
+        _id: z.coerce.string(),
+        name: z.string()
+    }).nullish()
+});
+export default FileSchema;
+export { FileSchema, FileBaseSchema };

package/dist/services/FileService.js

@@ -0,0 +1,22 @@
+import { AbstractService } from "@drax/crud-back";
+class FileService extends AbstractService {
+    constructor(FileRepository, baseSchema, fullSchema) {
+        super(FileRepository, baseSchema, fullSchema);
+        this._validateOutput = true;
+    }
+    async registerUploadedFile(data) {
+        return await this.create(data);
+    }
+    async registerDownloadHit(relativePath) {
+        const file = await this.findOneBy('relativePath', relativePath);
+        if (!file) {
+            return null;
+        }
+        return await this.updatePartial(file._id, {
+            hits: (file.hits || 0) + 1,
+            lastAccess: new Date()
+        });
+    }
+}
+export default FileService;
+export { FileService };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.11.0",
+  "version": "3.1.0",
   "description": "Media files",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -20,8 +20,8 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^2.11.0",
-    "@drax/identity-back": "^2.11.0"
+    "@drax/common-back": "^3.0.0",
+    "@drax/identity-back": "^3.1.0"
   },
   "peerDependencies": {
     "@fastify/multipart": "^9.0.3",
@@ -39,5 +39,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.4.5"
   },
-  "gitHead": "8919d31d4d9512e48ac461b0876dc85a5849daea"
+  "gitHead": "262ea8f861c84ca1ad4d555545c5a94b95dbf25e"
 }

package/src/controllers/FileController.ts

@@ -0,0 +1,50 @@
+import FileServiceFactory from "../factory/services/FileServiceFactory.js";
+import {AbstractFastifyController, CustomRequest} from "@drax/crud-back";
+import FilePermissions from "../permissions/FilePermissions.js";
+import type {IFile, IFileBase} from "../interfaces/IFile";
+import {StoreManager} from "@drax/common-back";
+
+class FileController extends AbstractFastifyController<IFile, IFileBase, IFileBase>   {
+
+    constructor() {
+        super(FileServiceFactory.instance, FilePermissions)
+        this.tenantField = "tenant";
+        this.userField = "createdBy.id";
+
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+
+    async preUpdate(request: CustomRequest, payload:any):Promise<IFileBase>{
+        delete payload.relativePath;
+        delete payload.absolutePath;
+        delete payload.filename;
+
+
+        payload.updatedBy = {
+            id: request.rbac.userId,
+            username: request.rbac.username,
+        }
+
+        return payload
+    }
+
+    async postDelete(request: CustomRequest, item:IFile){
+        try {
+            await StoreManager.deleteFilepath(item.relativePath)
+        } catch (error) {
+            console.error(error)
+        }
+        return item
+    }
+}
+
+export default FileController;
+export {
+    FileController
+}

package/src/controllers/MediaController.ts

@@ -1,14 +1,13 @@
 import {
     CommonController,
     StoreManager,
-    UnauthorizedError,
-    UploadFileError,
     DraxConfig,
     CommonConfig,
 } from "@drax/common-back";
 import {join} from "path";
 import {MediaPermissions} from "../permissions/MediaPermissions.js";
-
+import {FileServiceFactory} from "../factory/services/FileServiceFactory.js";
+import path from 'node:path';
 const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
 const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : ''
 
@@ -30,6 +29,11 @@ class MediaController extends CommonController {
         try {
             request.rbac.assertPermission(MediaPermissions.UploadFile)
 
+            const createdBy = {
+                id: request.rbac.userId,
+                username: request.rbac.username,
+            }
+
             const dir = request.params.dir
             if (!this.validateDir(dir)) {
                 reply.statusCode = 400
@@ -50,13 +54,45 @@ class MediaController extends CommonController {
 
             const storedFile = await StoreManager.saveFile(file, destinationPath)
             const urlFile = `${BASE_URL}/api/file/${dir}/${year}/${month}/${storedFile.filename}`
-            return {
+            const relativePath = storedFile.path
+            const absolutePath = path.resolve(process.cwd(), relativePath);
+            const extension = StoreManager.getExtension(storedFile.filename)
+            const fileService = FileServiceFactory.instance
+
+
+            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true
+            if (FILE_METADATA === true) {
+                try {
+                    await fileService.registerUploadedFile({
+                        filename: storedFile.filename,
+                        relativePath: relativePath,
+                        absolutePath: absolutePath,
+                        size: storedFile.size,
+                        mimetype: storedFile.mimetype || data.mimetype,
+                        encoding: storedFile.encoding || data.encoding || '',
+                        extension,
+                        type: storedFile.mimetype?.split('/')[0] || '',
+                        lastAccess: new Date(),
+                        ttlSeconds: 0,
+                        hits: 0,
+                        url: urlFile,
+                        createdBy,
+                    })
+                } catch (e) {
+                    await StoreManager.deleteFile(destinationPath, storedFile.filename).catch(() => undefined)
+                    throw e
+                }
+            }
+
+            let theFile = {
                 filename: storedFile.filename,
                 filepath: storedFile.path,
                 size: storedFile.size,
                 mimetype: storedFile.mimetype,
                 url: urlFile,
             }
+
+            return theFile
         } catch (e) {
             this.handleError(e, reply)
         }
@@ -93,6 +129,14 @@ class MediaController extends CommonController {
 
             const fileDir = join(BASE_FILE_DIR, dir, year, month)
             //console.log("FILE_DIR: ", fileDir, " FILENAME:", filename)
+
+            //Agregar hit al archivo
+            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true
+            if (FILE_METADATA === true) {
+                const fileService = FileServiceFactory.instance
+                await fileService.registerDownloadHit(join(fileDir, filename))
+            }
+
             return reply.sendFile(filename, fileDir)
         } catch (e) {
             this.handleError(e, reply)

package/src/factory/services/FileServiceFactory.ts

@@ -0,0 +1,41 @@
+
+import FileMongoRepository from '../../repository/mongo/FileMongoRepository.js'
+import FileSqliteRepository from '../../repository/sqlite/FileSqliteRepository.js'
+import type {IFileRepository} from "../../interfaces/IFileRepository";
+import {FileService} from '../../services/FileService.js'
+import {FileBaseSchema, FileSchema} from "../../schemas/FileSchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class FileServiceFactory {
+    private static service: FileService;
+
+    public static get instance(): FileService {
+        if (!FileServiceFactory.service) {
+            
+            let repository: IFileRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new FileMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new FileSqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            
+            const baseSchema = FileBaseSchema;
+            const fullSchema = FileSchema;
+            FileServiceFactory.service = new FileService(repository, baseSchema, fullSchema);
+        }
+        return FileServiceFactory.service;
+    }
+}
+
+export default FileServiceFactory
+export {
+    FileServiceFactory
+}
+

package/src/index.ts

@@ -1,11 +1,38 @@
-import {MediaRoutes} from "./routes/MediaRoutes.js";
-import {MediaPermissions} from "./permissions/MediaPermissions.js";
+import { MediaRoutes } from "./routes/MediaRoutes.js";
+import { MediaPermissions } from "./permissions/MediaPermissions.js";
+import { FileRoutes } from "./routes/FileRoutes.js";
+import { FilePermissions } from "./permissions/FilePermissions.js";
+import FileSchema from "./schemas/FileSchema.js";
+import FileModel from "./models/FileModel.js";
+import FileMongoRepository from "./repository/mongo/FileMongoRepository.js";
+import FileSqliteRepository from "./repository/sqlite/FileSqliteRepository.js";
+import FileService from "./services/FileService.js";
+import FileServiceFactory from "./factory/services/FileServiceFactory.js";
+import FileController from "./controllers/FileController.js";
+import type { IFile, IFileBase } from "./interfaces/IFile";
+import type { IFileRepository } from "./interfaces/IFileRepository";
+
+export type {
+    IFile,
+    IFileBase,
+    IFileRepository
+}
 
 export {
     //Routes
     MediaRoutes,
+    FileRoutes,
 
     //Permissions
     MediaPermissions,
-}
+    FilePermissions,
 
+    //File
+    FileSchema,
+    FileModel,
+    FileMongoRepository,
+    FileSqliteRepository,
+    FileService,
+    FileServiceFactory,
+    FileController
+}