@drax/media-back 2.11.0 → 3.1.0

package/src/interfaces/IFile.ts

@@ -0,0 +1,67 @@
+interface IFileBase {
+    filename: string
+    relativePath: string
+    absolutePath: string
+    url: string
+    description?: string
+    tags?: Array<string>
+    mimetype: string
+    encoding: string
+    extension: string
+    size: number
+    type: string
+    lastAccess: Date
+    createdBy?: {
+        id?: string
+        username?: string
+    }
+    updatedBy?: {
+        id?: string
+        username?: string
+    }
+    createdFor?: string
+    ttlSeconds: number
+    expiresAt?: Date
+    isPublic?: boolean
+    hits?: number
+    createdAt?: Date
+    updatedAt?: Date
+    tenant?: any
+}
+
+interface IFile {
+    _id: string
+    filename: string
+    relativePath: string
+    absolutePath: string
+    url: string
+    description?: string
+    tags?: Array<string>
+    mimetype: string
+    encoding: string
+    extension: string
+    size: number
+    type: string
+    lastAccess: Date
+    createdBy?: {
+        id?: string
+        username?: string
+    }
+    updatedBy?: {
+        id?: string
+        username?: string
+    }
+    createdFor?: string
+    ttlSeconds: number
+    expiresAt?: Date
+    isPublic?: boolean
+    hits?: number
+    createdAt?: Date
+    updatedAt?: Date
+    tenant?: any
+}
+
+export type {
+    IFileBase,
+    IFile
+}

package/src/interfaces/IFileRepository.ts

@@ -0,0 +1,11 @@
+
+import type {IFile, IFileBase} from './IFile'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IFileRepository extends IDraxCrudRepository<IFile, IFileBase, IFileBase>{
+
+}
+
+export {IFileRepository}
+
+

package/src/models/FileModel.ts

@@ -0,0 +1,65 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IFile} from '../interfaces/IFile'
+
+const FileSchema = new mongoose.Schema<IFile>({
+    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<IFile, PaginateModel<IFile>>(MODEL_NAME, FileSchema, COLLECTION_NAME);
+
+export {
+    FileSchema,
+    FileModel
+}
+
+export default FileModel

package/src/permissions/FilePermissions.ts

@@ -0,0 +1,17 @@
+
+enum FilePermissions {
+
+    Create = "file:create",
+    Update = "file:update",
+    Delete = "file:delete",
+    View = "file:view",
+    ViewAll = "file:viewAll",
+    UpdateAll = "file:updateAll",
+    DeleteAll = "file:deleteAll",
+    Manage = "file:manage"
+
+}
+
+export { FilePermissions };
+export default FilePermissions;
+

package/src/repository/mongo/FileMongoRepository.ts

@@ -0,0 +1,22 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {FileModel} from "../../models/FileModel.js";
+import type {IFileRepository} from '../../interfaces/IFileRepository'
+import type {IFile, IFileBase} from "../../interfaces/IFile";
+
+
+class FileMongoRepository extends AbstractMongoRepository<IFile, IFileBase, IFileBase> implements IFileRepository {
+
+    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/src/repository/sqlite/FileSqliteRepository.ts

@@ -0,0 +1,46 @@
+
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import type {IFileRepository} from '../../interfaces/IFileRepository'
+import type {IFile, IFileBase} from "../../interfaces/IFile";
+import {SqliteTableField} from "@drax/common-back";
+
+class FileSqliteRepository extends AbstractSqliteRepository<IFile, IFileBase, IFileBase> implements IFileRepository {
+
+    protected db: any;
+    protected tableName: string = 'File';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = ['filename', 'relativePath', 'absolutePath', 'url', 'description', 'tags', 'mimetype', 'extension', 'type'];
+    protected booleanFields: string[] = ['isPublic'];
+    protected identifier: string = '_id';
+    protected populateFields = [
+        
+    ]
+    protected verbose: boolean = false;
+    protected tableFields: SqliteTableField[] = [
+        {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/src/routes/FileRoutes.ts

@@ -0,0 +1,36 @@
+
+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: FileController = 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/src/schemas/FileSchema.ts

@@ -0,0 +1,55 @@
+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/src/services/FileService.ts

@@ -0,0 +1,36 @@
+
+import type{IFileRepository} from "../interfaces/IFileRepository.js";
+import type {IFileBase, IFile} from "../interfaces/IFile.js";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class FileService extends AbstractService<IFile, IFileBase, IFileBase> {
+
+
+    constructor(FileRepository: IFileRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(FileRepository, baseSchema, fullSchema);
+
+        this._validateOutput = true
+
+    }
+
+    async registerUploadedFile(data: IFileBase): Promise<IFile> {
+        return await this.create(data);
+    }
+
+    async registerDownloadHit(relativePath: string): Promise<IFile | null> {
+        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}