@jrmc/adonis-attachment 3.2.1 → 3.3.0-beta.1

package/build/index.d.ts

@@ -2,6 +2,7 @@ import attachmentManager from './services/main.js';
 export { configure } from './configure.js';
 export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
+export { attachments } 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';

package/build/index.js

@@ -2,6 +2,7 @@ import attachmentManager from './services/main.js';
 export { configure } from './configure.js';
 export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
+export { attachments } 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';

package/build/src/attachment_manager.d.ts

@@ -6,7 +6,7 @@
  */
 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';
+import type { AttachmentAttributes, AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
 import { DeferQueue } from '@poppinss/defer';
 import Converter from './converters/converter.js';
 import { ResolvedAttachmentConfig } from './define_config.js';
@@ -15,8 +15,17 @@ export declare class AttachmentManager<KnownConverters extends Record<string, Co
     queue: DeferQueue;
     constructor(config: ResolvedAttachmentConfig<KnownConverters>, drive: DriveService);
     getConfig(): ResolvedAttachmentConfig<KnownConverters>;
-    createFromDbResponse(response: any): AttachmentType | null;
+    createFromDbResponse(response?: string | JSON): AttachmentType | null;
     createFromFile(input: MultipartFile): Promise<AttachmentType>;
+    createFromFiles(inputs: MultipartFile[]): Promise<(AttachmentBase & {
+        originalName: string;
+        variants?: import("./types/attachment.js").Variant[];
+        createVariant(key: string, input: import("./types/input.js").Input): Promise<import("./types/attachment.js").Variant>;
+        getVariant(variantName: string): import("./types/attachment.js").Variant | undefined;
+        getUrl(variantName?: string): Promise<string>;
+        getSignedUrl(variantNameOrOptions?: string | SignedURLOptions, signedUrlOptions?: SignedURLOptions): Promise<string>;
+        toObject(): AttachmentAttributes;
+    })[]>;
     createFromPath(input: string, name?: string): Promise<AttachmentType>;
     createFromBuffer(input: Buffer, name?: string): Promise<AttachmentType>;
     createFromBase64(input: string, name?: string): Promise<AttachmentType>;

package/build/src/attachment_manager.js

@@ -52,6 +52,9 @@ export class AttachmentManager {
         const attachment = new Attachment(this.#drive, attributes, input.tmpPath);
         return this.#configureAttachment(attachment);
     }
+    async createFromFiles(inputs) {
+        return Promise.all(inputs.map((input) => this.createFromFile(input)));
+    }
     async createFromPath(input, name) {
         const meta = await metaFormFile(input, name || input);
         if (meta.extname === '') {
@@ -142,15 +145,11 @@ export class AttachmentManager {
             await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {
                 if (attachment.variants) {
-                    if (attachment.options?.disk == 'fs') {
-                        const variantPath = attachment.variants[0].folder;
-                        await attachment.getDisk().deleteAll(variantPath);
-                    }
-                    else {
-                        for (const key in attachment.variants) {
-                            if (Object.prototype.hasOwnProperty.call(attachment.variants, key)) {
-                                await attachment.getDisk().delete(attachment.variants[key].path);
-                            }
+                    const variantPath = attachment.variants[0].folder;
+                    await attachment.getDisk().deleteAll(variantPath); // not compatible Minio, necessary for fs as not to leave an empty directory
+                    for (const key in attachment.variants) {
+                        if (Object.prototype.hasOwnProperty.call(attachment.variants, key)) {
+                            await attachment.getDisk().delete(attachment.variants[key].path);
                         }
                     }
                 }

package/build/src/converter_manager.d.ts

@@ -1,6 +1,6 @@
 import type { ConverterInitializeAttributes } from './types/converter.js';
 export declare class ConverterManager {
     #private;
-    constructor({ record, attributeName }: ConverterInitializeAttributes);
+    constructor({ record, attributeName, options }: ConverterInitializeAttributes);
     save(): Promise<void>;
 }

package/build/src/converter_manager.js

@@ -1,42 +1,54 @@
+import string from '@adonisjs/core/helpers/string';
 import db from '@adonisjs/lucid/services/db';
 import attachmentManager from '../services/main.js';
 import * as errors from './errors.js';
-import { getOptions } from './utils/helpers.js';
 export class ConverterManager {
     #record;
     #attributeName;
-    constructor({ record, attributeName }) {
+    #options;
+    constructor({ record, attributeName, options }) {
         this.#record = record;
         this.#attributeName = attributeName;
+        this.#options = options;
     }
     async save() {
-        const options = getOptions(this.#record, this.#attributeName);
-        const attachment = this.#record.$attributes[this.#attributeName];
-        const input = attachment.input;
-        const Model = this.#record.constructor;
-        const id = this.#record.$attributes['id'];
+        let attachments = this.#record.getAttachments({
+            attributeName: this.#attributeName,
+        });
+        const Model = this.#record.model.constructor;
+        const id = this.#record.model.$attributes['id'];
         const data = {};
-        if (options.variants) {
-            for (const option of options.variants) {
+        if (this.#options.variants) {
+            for (const option of this.#options.variants) {
                 const converter = (await attachmentManager.getConverter(option));
-                if (attachment && converter) {
-                    const output = await converter.handle({
-                        input,
-                        options: converter.options,
-                    });
-                    if (output === undefined) {
-                        throw new errors.E_CANNOT_PATH_BY_CONVERTER();
+                if (attachments && converter) {
+                    for (let i = 0; i < attachments.length; i++) {
+                        const input = attachments[i].input;
+                        const output = await converter.handle({
+                            input,
+                            options: converter.options,
+                        });
+                        if (output === undefined) {
+                            throw new errors.E_CANNOT_PATH_BY_CONVERTER();
+                        }
+                        const variant = await attachments[i].createVariant(option, output);
+                        await attachmentManager.save(variant);
                     }
-                    const variant = await attachment.createVariant(option, output);
-                    await attachmentManager.save(variant);
                 }
             }
         }
-        data[this.#attributeName] = JSON.stringify(attachment.toObject());
+        if (Array.isArray(this.#record.model.$original[this.#attributeName])) {
+            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments.map((att) => att.toObject()));
+        }
+        else {
+            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments[0].toObject());
+        }
         const trx = await db.transaction();
         trx.after('rollback', () => {
-            for (const variant of attachment.variants) {
-                attachmentManager.delete(variant);
+            for (let i = 0; i < attachments.length; i++) {
+                for (const variant of attachments[i].variants) {
+                    attachmentManager.delete(variant);
+                }
             }
         });
         try {

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

@@ -4,5 +4,11 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { LucidModel } from '@adonisjs/lucid/types/model';
 import type { LucidOptions } from '../types/attachment.js';
+import type { AttributeOfModelWithAttachment } from '../types/mixin.js';
+export declare const bootModel: (model: LucidModel & {
+    $attachments: AttributeOfModelWithAttachment;
+}) => void;
 export declare const attachment: (options?: LucidOptions) => (target: any, attributeName: string) => void;
+export declare const attachments: (options?: LucidOptions) => (target: any, attributeName: string) => void;

package/build/src/decorators/attachment.js

@@ -8,65 +8,86 @@ import attachmentManager from '../../services/main.js';
 import { optionsSym } from '../utils/symbols.js';
 import { defaultOptionsDecorator } from '../utils/default_values.js';
 import { afterFindHook, afterFetchHook, beforeSaveHook, afterSaveHook, beforeDeleteHook, } from '../utils/hooks.js';
-import { clone } from '../utils/helpers.js';
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
-export const attachment = (options) => {
+export const bootModel = (model) => {
+    model.boot();
+    model.$attachments = structuredClone(defaultStateAttributeMixin);
+    /**
+     * Registering all hooks only once
+     */
+    if (!model.$hooks.has('find', afterFindHook)) {
+        model.after('find', afterFindHook);
+    }
+    if (!model.$hooks.has('fetch', afterFetchHook)) {
+        model.after('fetch', afterFetchHook);
+    }
+    if (!model.$hooks.has('paginate', afterFetchHook)) {
+        model.after('paginate', afterFetchHook);
+    }
+    if (!model.$hooks.has('save', beforeSaveHook)) {
+        model.before('save', beforeSaveHook);
+    }
+    if (!model.$hooks.has('save', afterSaveHook)) {
+        model.after('save', afterSaveHook);
+    }
+    if (!model.$hooks.has('delete', beforeDeleteHook)) {
+        model.before('delete', beforeDeleteHook);
+    }
+};
+const makeColumnOptions = (options) => {
+    const { disk, folder, variants, meta, rename, ...columnOptions } = {
+        ...defaultOptionsDecorator,
+        ...options,
+    };
+    return {
+        consume: (value) => {
+            if (value) {
+                const attachment = attachmentManager.createFromDbResponse(value);
+                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 {
+                return null;
+            }
+        },
+        prepare: (value) => (value ? JSON.stringify(value.toObject()) : null),
+        serialize: (value) => (value ? value.toJSON() : null),
+        ...columnOptions,
+    };
+};
+const makeAttachmentDecorator = (columnOptionsTransformer) => (options) => {
     return function (target, attributeName) {
         if (!target[optionsSym]) {
             target[optionsSym] = {};
         }
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
-        Model.boot();
-        Model.$attachments = clone(defaultStateAttributeMixin);
-        /**
-         * Registering all hooks only once
-         */
-        if (!Model.$hooks.has('find', afterFindHook)) {
-            Model.after('find', afterFindHook);
-        }
-        if (!Model.$hooks.has('fetch', afterFetchHook)) {
-            Model.after('fetch', afterFetchHook);
-        }
-        if (!Model.$hooks.has('paginate', afterFetchHook)) {
-            Model.after('paginate', afterFetchHook);
-        }
-        if (!Model.$hooks.has('save', beforeSaveHook)) {
-            Model.before('save', beforeSaveHook);
-        }
-        if (!Model.$hooks.has('save', afterSaveHook)) {
-            Model.after('save', afterSaveHook);
-        }
-        if (!Model.$hooks.has('delete', beforeDeleteHook)) {
-            Model.before('delete', beforeDeleteHook);
-        }
-        const { disk, folder, variants, meta, rename, ...columnOptions } = {
-            ...defaultOptionsDecorator,
-            ...options,
-        };
-        Model.$addColumn(attributeName, {
-            consume: (value) => {
-                if (value) {
-                    const attachment = attachmentManager.createFromDbResponse(value);
-                    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 {
-                    return null;
-                }
-            },
-            prepare: (value) => (value ? JSON.stringify(value.toObject()) : null),
-            serialize: (value) => (value ? value.toJSON() : null),
-            ...columnOptions,
-        });
+        bootModel(Model);
+        const columnOptions = makeColumnOptions(options);
+        const transformedColumnOptions = columnOptionsTransformer
+            ? columnOptionsTransformer(columnOptions)
+            : columnOptions;
+        Model.$addColumn(attributeName, transformedColumnOptions);
     };
 };
+export const attachment = makeAttachmentDecorator();
+export const attachments = makeAttachmentDecorator((columnOptions) => ({
+    consume: (value) => {
+        if (value) {
+            const data = typeof value === 'string' ? JSON.parse(value) : value;
+            return data.map(columnOptions.consume);
+        }
+        return null;
+    },
+    prepare: (value) => value ? JSON.stringify(value.map((v) => v.toObject())) : null,
+    serialize: (value) => (value ? value.map(columnOptions.serialize) : null),
+}));

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

@@ -75,6 +75,11 @@ export declare function Attachmentable<T extends Constructor>(superclass: T): {
     find: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T_1>>;
     readonly booted: boolean;
     boot: () => void;
+    after: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>[], "fetch">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     create: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
     all: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>[]>;
     namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
@@ -116,11 +121,6 @@ export declare function Attachmentable<T extends Constructor>(superclass: T): {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
-    after: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>[], "fetch">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     createMany: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
     findOrFail: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>>;
     findBy: {

package/build/src/mixins/attachmentable.js

@@ -11,12 +11,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { beforeSave, beforeFind, beforeFetch, beforePaginate, beforeCreate, } from '@adonisjs/lucid/orm';
-import { clone } from '../utils/helpers.js';
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
 import logger from '@adonisjs/core/services/logger';
 export function Attachmentable(superclass) {
     class ModelWithAttachment extends superclass {
-        $attachments = clone(defaultStateAttributeMixin);
+        $attachments = structuredClone(defaultStateAttributeMixin);
         static async warn() {
             logger.warn(`The "Attachmentable" mixin is deprecated and may be removed in a future version.`);
         }

package/build/src/services/record_with_attachment.d.ts

@@ -0,0 +1,28 @@
+import type { ModelWithAttachment } from '../types/mixin.js';
+import type { Attachment as AttachmentType } from '../types/attachment.js';
+import type { Record as RecordImplementation } from '../types/service.js';
+export default class Record implements RecordImplementation {
+    #private;
+    constructor(model: ModelWithAttachment);
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    commit(): Promise<void>;
+    /**
+     * During rollback we should remove the attached files.
+     */
+    rollback(): Promise<void>;
+    persist(): Promise<void>;
+    transaction(options?: {
+        enabledRollback: boolean;
+    }): Promise<void>;
+    preComputeUrl(): Promise<void>;
+    generateVariants(): Promise<void>;
+    detach(): Promise<PromiseSettledResult<void>[]>;
+    detachAll(): Promise<PromiseSettledResult<void>[]>;
+    get model(): ModelWithAttachment;
+    getAttachments(options: {
+        attributeName: string;
+        requiredOriginal?: boolean;
+    }): AttachmentType[];
+}

package/build/src/services/record_with_attachment.js

@@ -0,0 +1,223 @@
+import attachmentManager from '../../services/main.js';
+import { defaultStateAttributeMixin } from '../utils/default_values.js';
+import { Attachment } from '../attachments/attachment.js';
+import { optionsSym } from '../utils/symbols.js';
+import { ConverterManager } from '../converter_manager.js';
+import { E_CANNOT_CREATE_VARIANT } from '../errors.js';
+export default class Record {
+    #model;
+    constructor(model) {
+        this.#model = model;
+        if (!this.#model.$attachments) {
+            /**
+             * Empty previous $attachments
+             */
+            this.#model.$attachments = structuredClone(defaultStateAttributeMixin);
+        }
+    }
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    async commit() {
+        await Promise.allSettled(this.#model.$attachments.detached.map((attachment) => attachmentManager.delete(attachment)));
+    }
+    /**
+     * During rollback we should remove the attached files.
+     */
+    async rollback() {
+        await Promise.allSettled(this.#model.$attachments.attached.map((attachment) => attachmentManager.delete(attachment)));
+    }
+    async persist() {
+        const attachmentAttributeNames = this.#getDirtyAttributeNamesOfAttachment();
+        /**
+         * Persist attachments before saving the model to the database. This
+         * way if file saving fails we will not write anything to the
+         * database
+         */
+        await Promise.all(attachmentAttributeNames.map(async (name) => {
+            const originalAttachments = this.#getOriginalAttachmentsByAttributeName(name);
+            const newAttachments = this.#getAttachmentsByAttributeName(name);
+            const options = this.#getOptionsByAttributeName(name);
+            /**
+             * Skip when the attachment attributeName hasn't been updated
+             */
+            if (!originalAttachments && !newAttachments) {
+                return;
+            }
+            /**
+             * memorise attribute name for generate variants
+             */
+            this.#model.$attachments.dirtied.push(name);
+            for (let i = 0; i < newAttachments.length; i++) {
+                if (originalAttachments.includes(newAttachments[i])) {
+                    continue;
+                }
+                /**
+                 * If there is a new file and its local then we must save this
+                 * file.
+                 */
+                if (newAttachments[i]) {
+                    newAttachments[i].setOptions(options);
+                    this.#model.$attachments.attached.push(newAttachments[i]);
+                    /**
+                     * Also write the file to the disk right away
+                     */
+                    await attachmentManager.save(newAttachments[i]);
+                }
+            }
+        }));
+    }
+    async transaction(options = { enabledRollback: true }) {
+        try {
+            if (this.#model.$trx) {
+                this.#model.$trx.after('commit', () => this.commit());
+                if (options.enabledRollback) {
+                    this.#model.$trx.after('rollback', () => this.rollback());
+                }
+            }
+            else {
+                await this.commit();
+            }
+        }
+        catch (error) {
+            if (options.enabledRollback) {
+                await this.rollback();
+            }
+            throw error;
+        }
+    }
+    async preComputeUrl() {
+        const attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
+        await Promise.all(attachmentAttributeNames.map(async (name) => {
+            const options = this.#getOptionsByAttributeName(name);
+            if (this.#model.$attributes[name]) {
+                const attachments = this.#getAttachmentsByAttributeName(name);
+                for (let i = 0; i < attachments.length; i++) {
+                    attachments[i].setOptions(options);
+                    await attachmentManager.preComputeUrl(attachments[i]);
+                }
+            }
+        }));
+    }
+    async generateVariants() {
+        /* this.#model.$dirty is not avalable in afterSave hooks */
+        const attachmentAttributeNames = this.#model.$attachments.dirtied;
+        /**
+         * For all properties Attachment
+         * Launch async generation variants
+         */
+        await Promise.allSettled(attachmentAttributeNames.map((name) => {
+            const record = this;
+            attachmentManager.queue.push({
+                name: `${this.#model.constructor.name}-${name}`,
+                async run() {
+                    try {
+                        const converterManager = new ConverterManager({
+                            record,
+                            attributeName: name,
+                            options: record.#getOptionsByAttributeName(name),
+                        });
+                        await converterManager.save();
+                    }
+                    catch (err) {
+                        throw new E_CANNOT_CREATE_VARIANT([err.message]);
+                    }
+                },
+            });
+        }));
+    }
+    async detach() {
+        const attachmentAttributeNames = this.#getDirtyAttributeNamesOfAttachment();
+        /**
+         * Mark all original attachments for deletion
+         */
+        return Promise.allSettled(attachmentAttributeNames.map((name) => {
+            let attachments = [];
+            const options = this.#getOptionsByAttributeName(name);
+            if (this.#model.$dirty[name] === null) {
+                attachments = this.#getOriginalAttachmentsByAttributeName(name);
+            }
+            else {
+                const originalAttachments = this.#getOriginalAttachmentsByAttributeName(name);
+                const newAttachments = this.#getAttachmentsByAttributeName(name);
+                /**
+                 * Clean Attachments changed
+                 */
+                for (let i = 0; i < originalAttachments.length; i++) {
+                    if (newAttachments.includes(originalAttachments[i])) {
+                        continue;
+                    }
+                    /**
+                     * If there was an existing file, then we must get rid of it
+                     */
+                    if (originalAttachments[i]) {
+                        originalAttachments[i].setOptions(options);
+                        attachments.push(originalAttachments[i]);
+                    }
+                }
+            }
+            for (let i = 0; i < attachments.length; i++) {
+                attachments[i].setOptions(options);
+                this.#model.$attachments.detached.push(attachments[i]);
+            }
+        }));
+    }
+    async detachAll() {
+        const attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
+        /**
+         * Mark all attachments for deletion
+         */
+        return Promise.allSettled(attachmentAttributeNames.map((name) => {
+            const options = this.#getOptionsByAttributeName(name);
+            const attachments = this.#getAttachmentsByAttributeName(name);
+            for (let i = 0; i < attachments.length; i++) {
+                attachments[i].setOptions(options);
+                this.#model.$attachments.detached.push(attachments[i]);
+            }
+        }));
+    }
+    get model() {
+        return this.#model;
+    }
+    getAttachments(options) {
+        if (options.requiredOriginal) {
+            return this.#getOriginalAttachmentsByAttributeName(options.attributeName);
+        }
+        else {
+            return this.#getAttachmentsByAttributeName(options.attributeName);
+        }
+    }
+    #getAttachmentsByAttributeName(name) {
+        if (Array.isArray(this.#model.$attributes[name])) {
+            return this.#model.$attributes[name];
+        }
+        return [this.#model.$attributes[name]];
+    }
+    #getOriginalAttachmentsByAttributeName(name) {
+        if (Array.isArray(this.#model.$original[name])) {
+            return this.#model.$original[name];
+        }
+        return [this.#model.$original[name]];
+    }
+    #getOptionsByAttributeName(name) {
+        return this.#model.constructor.prototype[optionsSym]?.[name];
+    }
+    #getAttributeNamesOfAttachment() {
+        return Object.keys(this.#model.$attributes).filter((name) => {
+            const value = this.#model.$attributes[name];
+            return (value instanceof Attachment ||
+                (Array.isArray(value) && value.every((item) => item instanceof Attachment)));
+        });
+    }
+    #getDirtyAttributeNamesOfAttachment() {
+        return Object.keys(this.#model.$dirty).filter((name) => {
+            const dirtyValue = this.#model.$dirty[name];
+            const originalValue = this.#model.$original[name]; // if dirtyValue is null, check original type
+            const isDirtyAttachment = dirtyValue instanceof Attachment ||
+                (Array.isArray(dirtyValue) && dirtyValue.every((item) => item instanceof Attachment));
+            const isOriginalAttachment = originalValue instanceof Attachment ||
+                (Array.isArray(originalValue) && originalValue.every((item) => item instanceof Attachment));
+            return isDirtyAttachment || isOriginalAttachment;
+        });
+    }
+}

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

@@ -4,17 +4,19 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { Record } from './service.js';
 import type { BinPaths } from './config.js';
 import type { Input } from './input.js';
-import type { ModelWithAttachment } from './mixin.js';
+import type { LucidOptions } from './attachment.js';
 export type Converter = {
     options?: ConverterOptions;
     binPaths?: BinPaths;
     handle?: (attributes: ConverterAttributes) => Promise<Input | undefined>;
 };
 export type ConverterInitializeAttributes = {
-    record: ModelWithAttachment;
+    record: Record;
     attributeName: string;
+    options: LucidOptions;
 };
 export type ConverterAttributes = {
     input: Input;

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

@@ -3,3 +3,4 @@ export * from './config.js';
 export * from './converter.js';
 export * from './input.js';
 export * from './mixin.js';
+export * from './service.js';

package/build/src/types/index.js

@@ -3,3 +3,4 @@ export * from './config.js';
 export * from './converter.js';
 export * from './input.js';
 export * from './mixin.js';
+export * from './service.js';

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

@@ -9,7 +9,7 @@ import type { Attachment } from './attachment.js';
 export type AttributeOfModelWithAttachment = {
     attached: Attachment[];
     detached: Attachment[];
-    attributesModified: string[];
+    dirtied: string[];
 };
 export type ModelWithAttachment = LucidRow & {
     $attachments: AttributeOfModelWithAttachment;

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

@@ -0,0 +1,17 @@
+import type { Attachment } from './attachment.js';
+import type { ModelWithAttachment } from './mixin.js';
+export interface Record {
+    model: ModelWithAttachment;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    persist(): Promise<void>;
+    transaction(options?: {
+        enabledRollback: boolean;
+    }): Promise<void>;
+    preComputeUrl(): Promise<void>;
+    generateVariants(): Promise<void>;
+    getAttachments(options: {
+        attributeName: string;
+        requiredOriginal?: boolean;
+    }): Attachment[];
+}

package/build/src/types/service.js

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

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

@@ -15,5 +15,5 @@ export declare const defaultOptionsDecorator: {
 export declare const defaultStateAttributeMixin: {
     attached: never[];
     detached: never[];
-    attributesModified: never[];
+    dirtied: never[];
 };

package/build/src/utils/default_values.js

@@ -15,5 +15,5 @@ export const defaultOptionsDecorator = {
 export const defaultStateAttributeMixin = {
     attached: [],
     detached: [],
-    attributesModified: [],
+    dirtied: [],
 };

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

@@ -4,13 +4,7 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import type { LucidOptions } from '../types/attachment.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 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 streamToTempFile(input: NodeJS.ReadableStream): Promise<string>;

package/build/src/utils/helpers.js

@@ -11,20 +11,8 @@ import fs from 'node:fs/promises';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import { createWriteStream } from 'node:fs';
-import { Attachment } from '../attachments/attachment.js';
 import * as errors from '../errors.js';
-import { optionsSym } from './symbols.js';
 const streamPipeline = promisify(pipeline);
-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];
-}
 export function cleanObject(obj) {
     if (obj === null || typeof obj !== 'object') {
         return obj;
@@ -43,9 +31,6 @@ export function cleanObject(obj) {
     }
     return cleanedObj;
 }
-export function clone(object) {
-    return JSON.parse(JSON.stringify(object));
-}
 export async function use(module) {
     try {
         const result = await import(module);

package/build/src/utils/hooks.js

@@ -4,16 +4,12 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-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';
+import Record from '../services/record_with_attachment.js';
 // @afterFind()
 export const afterFindHook = async (instance) => {
     const modelInstance = instance;
-    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-    await Promise.all(attachmentAttributeNames.map((attributeName) => {
-        return preComputeUrl(modelInstance, attributeName);
-    }));
+    const model = new Record(modelInstance);
+    await model.preComputeUrl();
 };
 // @afterFetch()
 // @afterPaginate()
@@ -24,73 +20,21 @@ export const afterFetchHook = async (instance) => {
 // @beforeSave()
 export const beforeSaveHook = async (instance) => {
     const modelInstance = instance;
-    const attachmentAttributeNames = getDirtyAttachmentAttributeNames(modelInstance);
-    /**
-     * Empty previous $attachments
-     */
-    modelInstance.$attachments = clone(defaultStateAttributeMixin);
-    /**
-     * Set attributes Attachment type modified
-     */
-    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
-     * database
-     */
-    await Promise.all(attachmentAttributeNames.map((attributeName) => persistAttachment(modelInstance, attributeName)));
-    try {
-        if (modelInstance.$trx) {
-            modelInstance.$trx.after('commit', () => commit(modelInstance));
-            modelInstance.$trx.after('rollback', () => rollback(modelInstance));
-        }
-        else {
-            await commit(modelInstance);
-        }
-    }
-    catch (error) {
-        await rollback(modelInstance);
-        throw error;
-    }
+    const model = new Record(modelInstance);
+    await model.detach();
+    await model.persist();
+    await model.transaction();
 };
 // @afterSave()
 export const afterSaveHook = async (instance) => {
     const modelInstance = instance;
-    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-    /**
-     * For all properties Attachment
-     * Launch async generation variants
-     */
-    await Promise.all(attachmentAttributeNames.map((attributeName) => {
-        if (modelInstance.$attachments.attributesModified.includes(attributeName)) {
-            return generateVariants(modelInstance, attributeName);
-        }
-    }));
+    const model = new Record(modelInstance);
+    await model.generateVariants();
 };
 // @beforeDelete()
 export const beforeDeleteHook = async (instance) => {
     const modelInstance = instance;
-    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-    /**
-     * create $attachments
-     */
-    modelInstance.$attachments = clone(defaultStateAttributeMixin);
-    /**
-     * Mark all attachments for deletion
-     */
-    attachmentAttributeNames.map((attributeName) => {
-        if (modelInstance.$attributes[attributeName]) {
-            modelInstance.$attachments.detached.push(modelInstance.$attributes[attributeName]);
-        }
-    });
-    /**
-     * If model is using transaction, then wait for the transaction
-     * to settle
-     */
-    if (modelInstance.$trx) {
-        modelInstance.$trx.after('commit', () => commit(modelInstance));
-    }
-    else {
-        await commit(modelInstance);
-    }
+    const model = new Record(modelInstance);
+    await model.detachAll();
+    await model.transaction({ enabledRollback: false });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "3.2.1",
+  "version": "3.3.0-beta.1",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -115,7 +115,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "volta": {
     "node": "20.17.0"

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

@@ -1,24 +0,0 @@
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */
-import type { ModelWithAttachment } from '../types/mixin.js';
-/**
- * During commit, we should cleanup the old detached files
- */
-export declare function commit(modelInstance: ModelWithAttachment): Promise<void>;
-/**
- * During rollback we should remove the attached files.
- */
-export declare function rollback(modelInstance: ModelWithAttachment): Promise<void>;
-/**
- * Persist attachment for a given attachment attributeName
- */
-export declare function persistAttachment(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;
-export declare function preComputeUrl(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;
-/**
- * Launch converter by variant option
- */
-export declare function generateVariants(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;

package/build/src/utils/actions.js

@@ -1,90 +0,0 @@
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */
-import attachmentManager from '../../services/main.js';
-import { getOptions } from './helpers.js';
-import { ConverterManager } from '../converter_manager.js';
-import { E_CANNOT_CREATE_VARIANT } from '../errors.js';
-/**
- * During commit, we should cleanup the old detached files
- */
-export async function commit(modelInstance) {
-    await Promise.allSettled(modelInstance.$attachments.detached.map((attachment) => attachmentManager.delete(attachment)));
-}
-/**
- * During rollback we should remove the attached files.
- */
-export async function rollback(modelInstance) {
-    await Promise.allSettled(modelInstance.$attachments.attached.map((attachment) => attachmentManager.delete(attachment)));
-}
-/**
- * Persist attachment for a given attachment attributeName
- */
-export async function persistAttachment(modelInstance, attributeName) {
-    const existingFile = modelInstance.$original[attributeName];
-    const newFile = modelInstance.$attributes[attributeName];
-    const options = getOptions(modelInstance, attributeName);
-    /**
-     * Skip when the attachment attributeName hasn't been updated
-     */
-    if (existingFile === newFile) {
-        return;
-    }
-    /**
-     * There was an existing file, but there is no new file. Hence we must
-     * remove the existing file.
-     */
-    if (existingFile && !newFile) {
-        existingFile.setOptions(options);
-        modelInstance.$attachments.detached.push(existingFile);
-        return;
-    }
-    /**
-     * If there is a new file and its local then we must save this
-     * file.
-     */
-    if (newFile) {
-        newFile.setOptions(options);
-        modelInstance.$attachments.attached.push(newFile);
-        /**
-         * If there was an existing file, then we must get rid of it
-         */
-        if (existingFile) {
-            existingFile.setOptions(options);
-            modelInstance.$attachments.detached.push(existingFile);
-        }
-        /**
-         * Also write the file to the disk right away
-         */
-        await attachmentManager.save(newFile);
-    }
-}
-export async function preComputeUrl(modelInstance, attributeName) {
-    const attachment = modelInstance.$attributes[attributeName];
-    const options = getOptions(modelInstance, attributeName);
-    attachment.setOptions(options);
-    return attachmentManager.preComputeUrl(attachment);
-}
-/**
- * Launch converter by variant option
- */
-export async function generateVariants(modelInstance, attributeName) {
-    attachmentManager.queue.push({
-        name: `${modelInstance.constructor.name}-${attributeName}`,
-        async run() {
-            try {
-                const converterManager = new ConverterManager({
-                    record: modelInstance,
-                    attributeName,
-                });
-                await converterManager.save();
-            }
-            catch (err) {
-                throw new E_CANNOT_CREATE_VARIANT([err.message]);
-            }
-        },
-    });
-}