@jrmc/adonis-attachment 2.4.0 → 2.4.2

package/build/src/attachment_manager.d.ts

@@ -9,17 +9,16 @@ import type { MultipartFile } from '@adonisjs/core/bodyparser';
 import type { AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
 import type { ResolvedAttachmentConfig } from './types/config.js';
 import { DeferQueue } from '@poppinss/defer';
-import { Attachment } from './attachments/attachment.js';
 import Converter from './converters/converter.js';
 export declare class AttachmentManager {
     #private;
     queue: DeferQueue;
     constructor(config: ResolvedAttachmentConfig, drive: DriveService);
     getConfig(): ResolvedAttachmentConfig;
-    createFromDbResponse(response: any): Attachment | null;
-    createFromFile(file: MultipartFile): Promise<Attachment>;
-    createFromBuffer(buffer: Buffer, name?: string): Promise<Attachment>;
-    createFromBase64(data: string, name?: string): Promise<Attachment>;
+    createFromDbResponse(response: any): AttachmentType | null;
+    createFromFile(file: MultipartFile): Promise<AttachmentType>;
+    createFromBuffer(buffer: Buffer, name?: string): Promise<AttachmentType>;
+    createFromBase64(data: string, name?: string): Promise<AttachmentType>;
     getConverter(key: string): Promise<void | Converter>;
     computeUrl(attachment: AttachmentType | AttachmentBase, signedUrlOptions?: SignedURLOptions): Promise<void>;
     preComputeUrl(attachment: AttachmentType): Promise<void>;

package/build/src/attachment_manager.js

@@ -33,7 +33,8 @@ export class AttachmentManager {
                 throw new errors.E_CANNOT_CREATE_ATTACHMENT([attribute]);
             }
         });
-        return new Attachment(this.#drive, attributes);
+        const attachment = new Attachment(this.#drive, attributes);
+        return this.#configureAttachment(attachment);
     }
     async createFromFile(file) {
         const attributes = {
@@ -45,14 +46,16 @@ export class AttachmentManager {
         if (!file.tmpPath) {
             throw new errors.ENOENT();
         }
-        return new Attachment(this.#drive, attributes, file.tmpPath);
+        const attachment = new Attachment(this.#drive, attributes, file.tmpPath);
+        return this.#configureAttachment(attachment);
     }
     async createFromBuffer(buffer, name) {
         if (!Buffer.isBuffer(buffer)) {
             throw new errors.E_ISNOT_BUFFER();
         }
         const attributes = await createAttachmentAttributes(buffer, name);
-        return new Attachment(this.#drive, attributes, buffer);
+        const attachment = new Attachment(this.#drive, attributes, buffer);
+        return this.#configureAttachment(attachment);
     }
     async createFromBase64(data, name) {
         const base64Data = data.replace(/^data:([A-Za-z-+\/]+);base64,/, '');
@@ -111,8 +114,7 @@ export class AttachmentManager {
     }
     async delete(attachment) {
         if (attachment.path) {
-            const filePath = attachment.path;
-            await attachment.getDisk().delete(filePath);
+            await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {
                 if (attachment.variants) {
                     const variantPath = attachment.variants[0].folder;
@@ -120,5 +122,21 @@ export class AttachmentManager {
                 }
             }
         }
+        if (attachment.originalPath) {
+            await attachment.getDisk().delete(attachment.originalPath);
+        }
+    }
+    // private methods
+    #configureAttachment(attachment) {
+        if (this.#config.meta !== undefined) {
+            attachment.setOptions({ meta: this.#config.meta });
+        }
+        if (this.#config.rename !== undefined) {
+            attachment.setOptions({ rename: this.#config.rename });
+        }
+        if (this.#config.preComputeUrl !== undefined) {
+            attachment.setOptions({ preComputeUrl: this.#config.preComputeUrl });
+        }
+        return attachment;
     }
 }

package/build/src/attachments/attachment.d.ts

@@ -13,11 +13,21 @@ export declare class Attachment extends AttachmentBase implements AttachmentInte
     originalName: string;
     variants?: Variant[];
     constructor(drive: DriveService, attributes: AttachmentAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get name(): string;
+    /**
+     * Methods
+     */
     createVariant(key: string, input: Input): Promise<Variant>;
     getVariant(variantName: string): Variant | undefined;
     getUrl(variantName?: string): Promise<string>;
     getSignedUrl(variantNameOrOptions?: string | SignedURLOptions, signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
+    /**
+     *
+     */
     toObject(): AttachmentAttributes;
     toJSON(): Object;
 }

package/build/src/attachments/attachment.js

@@ -22,6 +22,18 @@ export class Attachment extends AttachmentBase {
             });
         }
     }
+    /**
+     * Getters
+     */
+    get name() {
+        if (this.options && this.options.rename === false) {
+            return this.originalName;
+        }
+        return super.name;
+    }
+    /**
+     * Methods
+     */
     async createVariant(key, input) {
         const attributes = {
             ...(await createAttachmentAttributes(input)),
@@ -72,13 +84,6 @@ export class Attachment extends AttachmentBase {
             ...this.options,
             ...options,
         };
-        if (!this.path) {
-            if (!this.options.rename) {
-                this.name = this.originalName;
-            }
-            this.folder = this.options.folder;
-            this.path = path.join(this.folder, this.name);
-        }
         if (this.variants) {
             this.variants.forEach((v) => {
                 v.setOptions({
@@ -89,6 +94,9 @@ export class Attachment extends AttachmentBase {
         }
         return this;
     }
+    /**
+     *
+     */
     toObject() {
         const variants = this.variants?.map((v) => v.toObject());
         return {
@@ -103,7 +111,7 @@ export class Attachment extends AttachmentBase {
             originalName: this.originalName,
             size: this.size,
             extname: this.extname,
-            mimetype: this.mimeType,
+            mimeType: this.mimeType,
             meta: this.meta,
         };
         if (this.variants) {
@@ -111,7 +119,7 @@ export class Attachment extends AttachmentBase {
                 data[v.key] = {
                     name: v.name,
                     extname: v.extname,
-                    mimetype: v.mimeType,
+                    mimeType: v.mimeType,
                     meta: v.meta,
                     size: v.size,
                 };

package/build/src/attachments/attachment_base.d.ts

@@ -8,22 +8,33 @@ import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { LucidOptions, AttachmentBaseAttributes, AttachmentBase as AttachmentBaseInterface } from '../types/attachment.js';
 import type { Exif, Input } from '../types/input.js';
 export declare class AttachmentBase implements AttachmentBaseInterface {
+    #private;
     drive: DriveService;
     input?: Input;
-    name: string;
     size: number;
     extname: string;
     mimeType: string;
     meta?: Exif;
-    folder?: string;
-    path?: string;
+    originalPath?: string;
     url?: string;
     options?: LucidOptions;
     constructor(drive: DriveService, attributes: AttachmentBaseAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get name(): string;
+    get folder(): string | undefined;
+    get path(): string;
+    /**
+     * Methods
+     */
     getDisk(): import("flydrive").Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
+    /**
+     *
+     */
     toObject(): AttachmentBaseAttributes;
     toJSON(): Object;
 }

package/build/src/attachments/attachment_base.js

@@ -4,18 +4,19 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
 import { defaultOptionsDecorator } from '../utils/default_values.js';
 export class AttachmentBase {
     drive;
     input;
-    name;
+    #name;
+    #folder;
     size;
     extname;
     mimeType;
     meta;
-    folder;
-    path;
+    originalPath;
     url;
     options;
     constructor(drive, attributes, input) {
@@ -24,17 +25,35 @@ export class AttachmentBase {
         this.meta = attributes.meta;
         this.extname = attributes.extname;
         this.mimeType = attributes.mimeType;
-        this.folder = attributes.folder;
-        this.path = attributes.path;
-        this.options = defaultOptionsDecorator;
-        this.drive = drive;
+        this.originalPath = attributes.path;
+        this.#folder = attributes.folder;
         if (attributes.name) {
-            this.name = attributes.name;
+            this.#name = attributes.name;
         }
         else {
-            this.name = `${cuid()}.${this.extname}`;
+            this.#name = `${cuid()}.${this.extname}`;
+        }
+        this.options = defaultOptionsDecorator;
+        this.drive = drive;
+    }
+    /**
+     * Getters
+     */
+    get name() {
+        return this.#name;
+    }
+    get folder() {
+        if (this.options) {
+            return this.options?.folder;
         }
+        return this.#folder;
+    }
+    get path() {
+        return path.join(this.folder, this.name);
     }
+    /**
+     * Methods
+     */
     getDisk() {
         return this.drive.use(this.options?.disk);
     }
@@ -51,6 +70,9 @@ export class AttachmentBase {
         };
         return this;
     }
+    /**
+     *
+     */
     toObject() {
         return {
             name: this.name,

package/build/src/attachments/variant_attachment.d.ts

@@ -9,8 +9,15 @@ import type { VariantAttributes, Variant as VariantInterface } from '../types/at
 import type { Input } from '../types/input.js';
 import { AttachmentBase } from './attachment_base.js';
 export declare class Variant extends AttachmentBase implements VariantInterface {
+    #private;
     key: string;
-    folder: string;
     constructor(drive: DriveService, attributes: VariantAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get folder(): string;
+    /**
+     *
+     */
     toObject(): VariantAttributes;
 }

package/build/src/attachments/variant_attachment.js

@@ -4,17 +4,24 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import path from 'node:path';
 import { AttachmentBase } from './attachment_base.js';
 export class Variant extends AttachmentBase {
     key;
-    folder;
+    #folder;
     constructor(drive, attributes, input) {
         super(drive, attributes, input);
         this.key = attributes.key;
-        this.folder = attributes.folder;
-        this.path = path.join(this.folder, this.name);
+        this.#folder = attributes.folder;
     }
+    /**
+     * Getters
+     */
+    get folder() {
+        return this.#folder;
+    }
+    /**
+     *
+     */
     toObject() {
         return {
             key: this.key,

package/build/src/decorators/attachment.js

@@ -12,23 +12,6 @@ export const attachment = (options) => {
         if (!target[optionsSym]) {
             target[optionsSym] = {};
         }
-        const defaultConfig = attachmentManager.getConfig();
-        const defaultOptions = {
-            meta: defaultConfig.meta !== undefined ? defaultConfig.meta : defaultOptionsDecorator.meta,
-            rename: defaultConfig.rename !== undefined ? defaultConfig.rename : defaultOptionsDecorator.rename,
-            preComputeUrl: defaultConfig.preComputeUrl !== undefined
-                ? defaultConfig.preComputeUrl
-                : defaultOptionsDecorator.preComputeUrl,
-        };
-        if (!options || options?.meta === undefined) {
-            options.meta = defaultOptions.meta;
-        }
-        if (!options || options?.rename === undefined) {
-            options.rename = defaultOptions.rename;
-        }
-        if (!options || options?.preComputeUrl === undefined) {
-            options.preComputeUrl = defaultOptions.preComputeUrl;
-        }
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
         Model.boot();
@@ -40,7 +23,16 @@ export const attachment = (options) => {
             consume: (value) => {
                 if (value) {
                     const attachment = attachmentManager.createFromDbResponse(value);
-                    attachment?.setOptions({ disk, folder, variants, meta, rename });
+                    attachment?.setOptions({ disk, folder, variants });
+                    if (options && options?.meta !== undefined) {
+                        attachment?.setOptions({ meta: options.meta });
+                    }
+                    if (options && options?.rename !== undefined) {
+                        attachment?.setOptions({ rename: options.rename });
+                    }
+                    if (options && options?.preComputeUrl !== undefined) {
+                        attachment?.setOptions({ preComputeUrl: options.preComputeUrl });
+                    }
                     return attachment;
                 }
                 else {

package/build/src/types/attachment.d.ts

@@ -12,12 +12,13 @@ export type AttachmentBase = {
     drive: DriveService;
     input?: Input;
     name: string;
+    folder?: string;
+    path?: string;
     size: number;
     extname: string;
     mimeType: string;
     meta?: Exif;
-    folder?: string;
-    path?: string;
+    originalPath?: string;
     url?: string;
     options?: LucidOptions;
     getDisk(): Disk;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {