@jrmc/adonis-attachment 2.3.0 → 2.3.2

package/README.md

@@ -7,6 +7,7 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 ## Links
 
 [View documentation](https://adonis-attachment.jrmc.dev/)
+
 [Discord](https://discord.gg/89eMn2vB)
 
 [ChangeLog](https://adonis-attachment.jrmc.dev/changelog.html)
@@ -22,41 +23,58 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
   - [x] documents thumbnail
   - [x] videos thumbnail
 - [ ] command regenerate
+- [ ] command make:convert
 - [x] adonis-drive/flydrive
 - [ ] jobs queue
 - [x] serialize
 
-### Meta data list (if available)
 
-- extension name
-- size
-- dimension (width, height)
-- created date
-- orientation
-- mime type
-- gps
+## Setup
 
-### Variants
+Install and configure the package:
 
-Configure differents images sizes and formats
+```sh
+node ace add @jrmc/adonis-attachment
+```
 
-### Regenerate (coming soon)
+## Sample
 
-Regenerate variantes files
+Simple upload file
 
-### Drive
+```ts
+// app/models/user.ts
+import { BaseModel } from '@adonisjs/lucid/orm'
+import { compose } from '@adonisjs/core/helpers'
+import { attachment, Attachmentable } from '@jrmc/adonis-attachment'
+import type { Attachment } from '@jrmc/adonis-attachment/types/attachment' // [!code highlight]
 
-Use [@adonisjs/drive](https://docs.adonisjs.com/guides/digging-deeper/drive) for private file and cloud services
+class User extends compose(BaseModel, Attachmentable) { // [!code highlight]
+  @attachment() // [!code highlight]
+  declare avatar: Attachment // [!code highlight]
+}
+```
 
-### Jobs queue (coming soon)
+---
 
-Couple with a job queue (recommended, optional)
+```ts
+// app/controllers/users_controller.ts
+import { attachmentManager } from '@jrmc/adonis-attachment' // [!code focus]
 
-## Setup
+class UsersController {
+  public store({ request }: HttpContext) {
+    const avatar = request.file('avatar')! // [!code focus]
+    const user = new User()
 
-Install and configure the package:
+    user.avatar = await attachmentManager.createFromFile(avatar) // [!code focus]
+    await user.save()
+  }
+}
+```
 
-```sh
-node ace add @jrmc/adonis-attachment
+---
+
+```edge
+<img src="{{ await user.avatar.getUrl() }}" loading="lazy" alt="" />
 ```
 
+Read [documentation](https://adonis-attachment.jrmc.dev/) for advanced usage(thumbnail video/pdf/doc, create from buffer/base64...)

package/build/index.d.ts

@@ -4,4 +4,5 @@ export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
 export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
+export * as errors from './src/errors.js';
 export { attachmentManager };

package/build/index.js

@@ -4,4 +4,5 @@ export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
 export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
+export * as errors from './src/errors.js';
 export { attachmentManager };

package/build/providers/attachment_provider.js

@@ -17,12 +17,11 @@ export default class AttachmentProvider {
             const { AttachmentManager } = await import('../src/attachment_manager.js');
             const attachmentConfig = this.app.config.get('attachment');
             const config = await configProvider.resolve(this.app, attachmentConfig);
-            const logger = await this.app.container.make('logger');
             const drive = await this.app.container.make('drive.manager');
             if (!config) {
                 throw new RuntimeException('Invalid config exported from "config/attachment.ts" file. Make sure to use the defineConfig method');
             }
-            this.#manager = new AttachmentManager(config, logger, drive);
+            this.#manager = new AttachmentManager(config, drive);
             return this.#manager;
         });
     }

package/build/src/adapters/exif.js

@@ -125,7 +125,7 @@ async function videoExif(input) {
                 dimension: {
                     width: data.streams[0].width,
                     height: data.streams[0].height,
-                }
+                },
             });
         });
     });

package/build/src/attachment_manager.d.ts

@@ -4,7 +4,6 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import type { LoggerService } from '@adonisjs/core/types';
 import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { MultipartFile } from '@adonisjs/core/bodyparser';
 import type { AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
@@ -13,7 +12,7 @@ import { Attachment } from './attachments/attachment.js';
 import Converter from './converters/converter.js';
 export declare class AttachmentManager {
     #private;
-    constructor(config: ResolvedAttachmentConfig, logger: LoggerService, drive: DriveService);
+    constructor(config: ResolvedAttachmentConfig, drive: DriveService);
     getConfig(): ResolvedAttachmentConfig;
     createFromDbResponse(response: any): Attachment | null;
     createFromFile(file: MultipartFile): Promise<Attachment>;

package/build/src/attachment_manager.js

@@ -4,17 +4,15 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import { Exception } from '@poppinss/utils';
+import * as errors from './errors.js';
 import { Attachment } from './attachments/attachment.js';
-import { createAttachmentAttributes } from './utils/helpers.js';
+import { createAttachmentAttributes, isBase64 } from './utils/helpers.js';
 import { exif } from './adapters/exif.js';
 const REQUIRED_ATTRIBUTES = ['name', 'size', 'extname', 'mimeType'];
 export class AttachmentManager {
-    #logger;
     #config;
     #drive;
-    constructor(config, logger, drive) {
-        this.#logger = logger;
+    constructor(config, drive) {
         this.#drive = drive;
         this.#config = config;
     }
@@ -28,7 +26,7 @@ export class AttachmentManager {
         const attributes = typeof response === 'string' ? JSON.parse(response) : response;
         REQUIRED_ATTRIBUTES.forEach((attribute) => {
             if (attributes[attribute] === undefined) {
-                throw new Exception(`Cannot create attachment from database response. Missing attribute "${attribute}"`);
+                throw new errors.E_CANNOT_CREATE_ATTACHMENT([attribute]);
             }
         });
         return new Attachment(this.#drive, attributes);
@@ -41,16 +39,22 @@ export class AttachmentManager {
             size: file.size,
         };
         if (!file.tmpPath) {
-            throw new Error("It's not a valid file");
+            throw new errors.ENOENT();
         }
         return new Attachment(this.#drive, attributes, file.tmpPath);
     }
     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);
     }
     async createFromBase64(data, name) {
         const base64Data = data.replace(/^data:([A-Za-z-+\/]+);base64,/, '');
+        if (!isBase64(base64Data)) {
+            throw new errors.E_ISNOT_BASE64();
+        }
         const buffer = Buffer.from(base64Data, 'base64');
         return await this.createFromBuffer(buffer, name);
     }
@@ -94,47 +98,22 @@ export class AttachmentManager {
         else {
             attachment.meta = undefined;
         }
-        try {
-            if (Buffer.isBuffer(attachment.input)) {
-                await attachment.getDisk().put(destinationPath, attachment.input);
-            }
-            else if (attachment.input) {
-                await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
-            }
+        if (Buffer.isBuffer(attachment.input)) {
+            await attachment.getDisk().put(destinationPath, attachment.input);
         }
-        catch (err) {
-            this.#logger.error({ err }, 'Error send file');
+        else if (attachment.input) {
+            await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
         }
     }
     async delete(attachment) {
         if (attachment.path) {
-            try {
-                const filePath = attachment.path;
-                try {
-                    await attachment.getDisk().delete(filePath);
+            const filePath = attachment.path;
+            await attachment.getDisk().delete(filePath);
+            if (attachment instanceof Attachment) {
+                if (attachment.variants) {
+                    const variantPath = attachment.variants[0].folder;
+                    await attachment.getDisk().deleteAll(variantPath);
                 }
-                catch (accessError) {
-                    if (accessError.code === 'ENOENT') {
-                        this.#logger.warn(`File not found: ${filePath}`);
-                    }
-                    else {
-                        throw accessError;
-                    }
-                }
-                if (attachment instanceof Attachment) {
-                    if (attachment.variants) {
-                        const variantPath = attachment.variants[0].folder;
-                        try {
-                            await attachment.getDisk().deleteAll(variantPath);
-                        }
-                        catch (rmError) {
-                            this.#logger.error(`Failed to remove variants folder: ${rmError.message}`);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                this.#logger.error(error);
             }
         }
     }

package/build/src/attachments/attachment.js

@@ -83,7 +83,7 @@ export class Attachment extends AttachmentBase {
             this.variants.forEach((v) => {
                 v.setOptions({
                     ...this.options,
-                    variants: []
+                    variants: [],
                 });
             });
         }

package/build/src/attachments/attachment_base.js

@@ -65,7 +65,7 @@ export class AttachmentBase {
         if (this.url) {
             return {
                 ...this.toObject(),
-                url: this.url
+                url: this.url,
             };
         }
         return this.toObject();

package/build/src/converters/autodetect_converter.js

@@ -27,7 +27,7 @@ export default class AutodetectConverter extends Converter {
         if (converter) {
             return await converter.handle({
                 input,
-                options
+                options,
             });
         }
     }

package/build/src/converters/document_thumbnail_converter.js

@@ -4,24 +4,28 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
 import ImageConverter from './image_converter.js';
 import { use } from '../utils/helpers.js';
 export default class DocumentThumbnailConverter extends Converter {
     async handle({ input, options }) {
-        const lib = await use('libreoffice-file-converter');
-        if (lib) {
+        try {
+            const lib = await use('libreoffice-file-converter');
             const LibreOfficeFileConverter = lib.LibreOfficeFileConverter;
             const outputBuffer = await this.documentToImage(LibreOfficeFileConverter, input);
             if (options && outputBuffer) {
                 const converter = new ImageConverter();
                 return await converter.handle({
                     input: outputBuffer,
-                    options
+                    options,
                 });
             }
             return outputBuffer;
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
     async documentToImage(LibreOfficeFileConverter, input) {
         let binaryPaths = undefined;
@@ -32,7 +36,7 @@ export default class DocumentThumbnailConverter extends Converter {
             childProcessOptions: {
                 timeout: 60 * 1000,
             },
-            binaryPaths
+            binaryPaths,
         });
         if (Buffer.isBuffer(input)) {
             const output = await libreOfficeFileConverter.convert({

package/build/src/converters/image_converter.js

@@ -4,12 +4,13 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
 import { use } from '../utils/helpers.js';
 export default class ImageConverter extends Converter {
     async handle({ input, options }) {
-        const sharp = await use('sharp');
-        if (sharp) {
+        try {
+            const sharp = await use('sharp');
             const resize = options?.resize || {};
             let format = options?.format || 'webp';
             let formatoptions = {};
@@ -24,5 +25,8 @@ export default class ImageConverter extends Converter {
                 .toBuffer();
             return buffer;
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
 }

package/build/src/converters/pdf_thumbnail_converter.js

@@ -7,24 +7,28 @@
 import os from 'node:os';
 import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
+import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
 import ImageConverter from './image_converter.js';
 import { use } from '../utils/helpers.js';
 export default class PdfThumbnailConverter extends Converter {
     async handle({ input, options }) {
-        const nodePoppler = await use('node-poppler');
-        if (nodePoppler) {
+        try {
+            const nodePoppler = await use('node-poppler');
             const Poppler = nodePoppler.Poppler;
             const filePath = await this.pdfToImage(Poppler, input);
             if (options && filePath) {
                 const converter = new ImageConverter();
                 return await converter.handle({
                     input: filePath,
-                    options
+                    options,
                 });
             }
             return filePath;
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
     async pdfToImage(Poppler, input) {
         let binPath = null;

package/build/src/converters/video_thumbnail_converter.js

@@ -7,25 +7,29 @@
 import os from 'node:os';
 import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
+import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
 import ImageConverter from './image_converter.js';
 import { bufferToTempFile, use } from '../utils/helpers.js';
 export default class VideoThumbnailConvert extends Converter {
     async handle({ input, options }) {
-        const ffmpeg = await use('fluent-ffmpeg');
-        if (ffmpeg) {
+        try {
+            const ffmpeg = await use('fluent-ffmpeg');
             const filePath = await this.videoToImage(ffmpeg, input);
             if (options && filePath) {
                 const converter = new ImageConverter();
                 return await converter.handle({
                     input: filePath,
-                    options
+                    options,
                 });
             }
             else {
                 return filePath;
             }
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
     async videoToImage(ffmpeg, input) {
         let file = input;
@@ -45,8 +49,7 @@ export default class VideoThumbnailConvert extends Converter {
                 count: 1,
                 filename,
                 folder,
-            })
-                .on('end', () => {
+            }).on('end', () => {
                 resolve(path.join(folder, filename));
             });
         });

package/build/src/decorators/attachment.js

@@ -16,7 +16,9 @@ export const attachment = (options) => {
         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,
+            preComputeUrl: defaultConfig.preComputeUrl !== undefined
+                ? defaultConfig.preComputeUrl
+                : defaultOptionsDecorator.preComputeUrl,
         };
         if (!options || options?.meta === undefined) {
             options.meta = defaultOptions.meta;

package/build/src/errors.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+/**
+ * Unable to write file to the destination
+ */
+export declare const E_CANNOT_WRITE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to read file
+ */
+export declare const E_CANNOT_READ_FILE: new (args: [key: string], options?: ErrorOptions) => import(
+/**
+ * Unable to read file
+ */
+"@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to delete file
+ */
+export declare const E_CANNOT_DELETE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to set file visibility
+ */
+export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to generate URL for a file
+ */
+export declare const E_CANNOT_GENERATE_URL: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * The file key has unallowed set of characters
+ */
+export declare const E_UNALLOWED_CHARACTERS: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Key post normalization leads to an empty string
+ */
+export declare const E_INVALID_KEY: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Missing package
+ */
+export declare const E_MISSING_PACKAGE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to create Attachment Object
+ */
+export declare const E_CANNOT_CREATE_ATTACHMENT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Is not a Buffer
+ */
+export declare const E_ISNOT_BUFFER: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Is not a Base64
+ */
+export declare const E_ISNOT_BASE64: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to read file
+ */
+export declare const ENOENT: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;

package/build/src/errors.js

@@ -0,0 +1,56 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { createError } from '@adonisjs/core/exceptions';
+import { errors } from 'flydrive';
+/**
+ * Unable to write file to the destination
+ */
+export const E_CANNOT_WRITE_FILE = errors.E_CANNOT_WRITE_FILE;
+/**
+ * Unable to read file
+ */
+export const E_CANNOT_READ_FILE = errors.E_CANNOT_READ_FILE;
+/**
+ * Unable to delete file
+ */
+export const E_CANNOT_DELETE_FILE = errors.E_CANNOT_DELETE_FILE;
+/**
+ * Unable to set file visibility
+ */
+export const E_CANNOT_SET_VISIBILITY = errors.E_CANNOT_SET_VISIBILITY;
+/**
+ * Unable to generate URL for a file
+ */
+export const E_CANNOT_GENERATE_URL = errors.E_CANNOT_GENERATE_URL;
+/**
+ * The file key has unallowed set of characters
+ */
+export const E_UNALLOWED_CHARACTERS = errors.E_UNALLOWED_CHARACTERS;
+/**
+ * Key post normalization leads to an empty string
+ */
+export const E_INVALID_KEY = errors.E_INVALID_KEY;
+/**
+ * Missing package
+ */
+export const E_MISSING_PACKAGE = createError('Missing package, please install "%s"', 'E_MISSING_PACKAGE');
+/**
+ * Unable to create Attachment Object
+ */
+export const E_CANNOT_CREATE_ATTACHMENT = createError('Cannot create attachment from database response. Missing attribute "%s"', 'E_CANNOT_CREATE_ATTACHMENT');
+/**
+ * Is not a Buffer
+ */
+export const E_ISNOT_BUFFER = createError('Is not a Buffer', 'E_ISNOT_BUFFER');
+/**
+ * Is not a Base64
+ */
+export const E_ISNOT_BASE64 = createError('Is not a Base64', 'E_ISNOT_BASE64');
+/**
+ * Unable to read file
+ */
+export const ENOENT = createError('File not found', 'ENOENT');

package/build/src/mixins/attachmentable.d.ts

@@ -369,7 +369,6 @@ export declare const Attachmentable: <Model extends NormalizeConstructor<typeof
         related<Name_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? any[Name_2]["client"] : never;
     }): Promise<void>;
     find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
-    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -416,6 +415,7 @@ export declare const Attachmentable: <Model extends NormalizeConstructor<typeof
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
     };
+    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
     findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
     findBy: {

package/build/src/mixins/attachmentable.js

@@ -10,9 +10,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-import { beforeSave, afterSave, beforeDelete, afterFind, afterFetch, afterPaginate } from '@adonisjs/lucid/orm';
-import { persistAttachment, commit, rollback, generateVariants, preComputeUrl } from '../utils/actions.js';
-import { clone, getAttachmentAttributeNames } from '../utils/helpers.js';
+import { beforeSave, afterSave, beforeDelete, afterFind, afterFetch, afterPaginate, } from '@adonisjs/lucid/orm';
+import { persistAttachment, commit, rollback, generateVariants, preComputeUrl, } from '../utils/actions.js';
+import { clone, getAttachmentAttributeNames, getDirtyAttachmentAttributeNames, } from '../utils/helpers.js';
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
 export const Attachmentable = (superclass) => {
     class ModelWithAttachment extends superclass {
@@ -27,7 +27,7 @@ export const Attachmentable = (superclass) => {
             await Promise.all(modelInstances.map((row) => this.afterFindHook(row)));
         }
         static async beforeSaveHook(modelInstance) {
-            const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
+            const attachmentAttributeNames = getDirtyAttachmentAttributeNames(modelInstance);
             /**
              * Empty previous $attachments
              */
@@ -35,11 +35,7 @@ export const Attachmentable = (superclass) => {
             /**
              * Set attributes Attachment type modified
              */
-            attachmentAttributeNames.forEach((attributeName) => {
-                if (modelInstance.$dirty[attributeName]) {
-                    modelInstance.$attachments.attributesModified.push(attributeName);
-                }
-            });
+            attachmentAttributeNames.forEach((attributeName) => modelInstance.$attachments.attributesModified.push(attributeName));
             /**
              * Persist attachments before saving the model to the database. This
              * way if file saving fails we will not write anything to the

package/build/src/utils/default_values.js

@@ -10,7 +10,7 @@ export const defaultOptionsDecorator = {
     preComputeUrl: false,
     variants: [],
     meta: true,
-    rename: true
+    rename: true,
 };
 export const defaultStateAttributeMixin = {
     attached: [],

package/build/src/utils/helpers.d.ts

@@ -8,6 +8,7 @@ import type { LucidOptions } from '../types/attachment.js';
 import type { Input } from '../types/input.js';
 import type { ModelWithAttachment } from '../types/mixin.js';
 export declare function getAttachmentAttributeNames(modelInstance: ModelWithAttachment): string[];
+export declare function getDirtyAttachmentAttributeNames(modelInstance: ModelWithAttachment): string[];
 export declare function getOptions(modelInstance: ModelWithAttachment, attributeName: string): LucidOptions;
 export declare function createAttachmentAttributes(input: Input, name?: string): Promise<{
     originalName: string;
@@ -19,3 +20,4 @@ export declare function cleanObject(obj: any): any;
 export declare function clone(object: Object): any;
 export declare function use(module: string): Promise<any>;
 export declare function bufferToTempFile(input: Buffer): Promise<string>;
+export declare function isBase64(str: string): boolean;

package/build/src/utils/helpers.js

@@ -9,13 +9,17 @@ import path from 'node:path';
 import fs from 'fs/promises';
 import { cuid } from '@adonisjs/core/helpers';
 import string from '@adonisjs/core/helpers/string';
-import logger from '@adonisjs/core/services/logger';
 import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
 import { Attachment } from '../attachments/attachment.js';
+import * as errors from '../errors.js';
 import { optionsSym } from './symbols.js';
 export function getAttachmentAttributeNames(modelInstance) {
     return Object.keys(modelInstance.$attributes).filter((attr) => modelInstance.$attributes[attr] instanceof Attachment);
 }
+export function getDirtyAttachmentAttributeNames(modelInstance) {
+    return Object.keys(modelInstance.$dirty).filter((attr) => modelInstance.$dirty[attr] instanceof Attachment ||
+        modelInstance.$original[attr] instanceof Attachment);
+}
 export function getOptions(modelInstance, attributeName) {
     return modelInstance.constructor.prototype[optionsSym]?.[attributeName];
 }
@@ -69,8 +73,8 @@ export async function use(module) {
         }
         return result;
     }
-    catch (error) {
-        logger.error({ err: error }, `Dependence missing, please install ${module}`);
+    catch (err) {
+        throw new errors.E_MISSING_PACKAGE([module], { cause: err });
     }
 }
 export async function bufferToTempFile(input) {
@@ -79,3 +83,16 @@ export async function bufferToTempFile(input) {
     await fs.writeFile(tempFilePath, input);
     return tempFilePath;
 }
+export function isBase64(str) {
+    const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+    if (!base64Regex.test(str)) {
+        return false;
+    }
+    try {
+        Buffer.from(str, 'base64').toString();
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -56,7 +56,6 @@
     "./attachment_provider": "./build/providers/attachment_provider.js"
   },
   "dependencies": {
-    "@poppinss/utils": "^6.7.3",
     "exifreader": "^4.23.3",
     "file-type": "^19.4.0"
   },
@@ -87,4 +86,4 @@
   "volta": {
     "node": "20.17.0"
   }
-}
+}