@jrmc/adonis-attachment 3.3.0-beta.4 → 4.0.0-beta.1

package/build/index.d.ts

@@ -1,10 +1,11 @@
 import attachmentManager from './services/main.js';
+import RegenerateService from './services/regenerate_service.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';
 export { attachmentManager };
+export { RegenerateService };
 export { type AttachmentVariants } from './src/types/config.js';

package/build/index.js

@@ -1,9 +1,10 @@
 import attachmentManager from './services/main.js';
+import RegenerateService from './services/regenerate_service.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';
 export { attachmentManager };
+export { RegenerateService };

package/build/services/regenerate_service.d.ts

@@ -0,0 +1,8 @@
+import type { LucidRow, LucidModel } from '@adonisjs/lucid/types/model';
+import type { RegenerateOptions } from '../src/types/regenerate.js';
+export default class RegenerateService {
+    #private;
+    model(Model: LucidModel, options?: RegenerateOptions): this;
+    row(row: LucidRow, options?: RegenerateOptions): this;
+    run(): Promise<void | void[]>;
+}

package/build/services/regenerate_service.js

@@ -0,0 +1,29 @@
+import RecordWithAttachment from '../src/services/record_with_attachment.js';
+export default class RegenerateService {
+    #Model;
+    #row;
+    #options;
+    model(Model, options = {}) {
+        this.#Model = Model;
+        this.#options = options;
+        return this;
+    }
+    row(row, options = {}) {
+        this.#row = row;
+        this.#options = options;
+        return this;
+    }
+    async run() {
+        if (this.#row) {
+            const record = new RecordWithAttachment(this.#row);
+            return record.regenerateVariants(this.#options);
+        }
+        else if (this.#Model) {
+            const entities = await this.#Model.all();
+            return Promise.all(entities.map(async (entity) => {
+                const record = new RecordWithAttachment(entity);
+                return record.regenerateVariants(this.#options);
+            }));
+        }
+    }
+}

package/build/src/attachment_manager.d.ts

@@ -7,14 +7,13 @@
 import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { MultipartFile } from '@adonisjs/core/bodyparser';
 import type { AttachmentAttributes, AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
+import type { ResolvedAttachmentConfig } from './define_config.js';
 import { DeferQueue } from '@poppinss/defer';
 import Converter from './converters/converter.js';
-import { ResolvedAttachmentConfig } from './define_config.js';
 export declare class AttachmentManager<KnownConverters extends Record<string, Converter>> {
     #private;
     queue: DeferQueue;
     constructor(config: ResolvedAttachmentConfig<KnownConverters>, drive: DriveService);
-    getConfig(): ResolvedAttachmentConfig<KnownConverters>;
     createFromDbResponse(response?: string | JSON): AttachmentType | null;
     createFromFile(input: MultipartFile): Promise<AttachmentType>;
     createFromFiles(inputs: MultipartFile[]): Promise<(AttachmentBase & {
@@ -34,6 +33,6 @@ export declare class AttachmentManager<KnownConverters extends Record<string, Co
     getConverter(key: string): Promise<void | Converter>;
     computeUrl(attachment: AttachmentType | AttachmentBase, signedUrlOptions?: SignedURLOptions): Promise<void>;
     preComputeUrl(attachment: AttachmentType): Promise<void>;
-    save(attachment: AttachmentBase): Promise<void>;
-    delete(attachment: AttachmentBase): Promise<void>;
+    write(attachment: AttachmentBase): Promise<void>;
+    remove(attachment: AttachmentBase): Promise<void>;
 }

package/build/src/attachment_manager.js

@@ -23,9 +23,6 @@ export class AttachmentManager {
         const concurrency = this.#config.queue?.concurrency || 1;
         this.queue = new DeferQueue({ concurrency });
     }
-    getConfig() {
-        return this.#config;
-    }
     createFromDbResponse(response) {
         if (response === null) {
             return null;
@@ -125,7 +122,7 @@ export class AttachmentManager {
             }
         }
     }
-    async save(attachment) {
+    async write(attachment) {
         const destinationPath = attachment.path;
         if (attachment.options?.meta) {
             attachment.meta = await ExifAdapter.exif(attachment.input, this.#config);
@@ -140,7 +137,7 @@ export class AttachmentManager {
             await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
         }
     }
-    async delete(attachment) {
+    async remove(attachment) {
         if (attachment.path) {
             await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {

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

@@ -30,6 +30,7 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
      * Methods
      */
     getDisk(): import("flydrive").Disk;
+    getStream(): Promise<import("stream").Readable>;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;

package/build/src/attachments/attachment_base.js

@@ -68,6 +68,9 @@ export class AttachmentBase {
     getDisk() {
         return this.drive.use(this.options?.disk);
     }
+    getStream() {
+        return this.getDisk().getStream(this.path);
+    }
     getUrl() {
         return this.getDisk().getUrl(this.path);
     }

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

@@ -8,11 +8,13 @@ import type { DriveService } from '@adonisjs/drive/types';
 import type { VariantAttributes, Variant as VariantInterface } from '../types/attachment.js';
 import type { Input } from '../types/input.js';
 import { AttachmentBase } from './attachment_base.js';
+import { BlurhashOptions } from '../types/converter.js';
 export declare class Variant extends AttachmentBase implements VariantInterface {
     #private;
     key: string;
     blurhash?: string;
     constructor(drive: DriveService, attributes: VariantAttributes, input?: Input);
+    generateBlurhash(options?: BlurhashOptions): Promise<void>;
     /**
      * Getters
      */

package/build/src/attachments/variant_attachment.js

@@ -5,6 +5,7 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import { AttachmentBase } from './attachment_base.js';
+import { imageToBlurhash } from '../utils/helpers.js';
 export class Variant extends AttachmentBase {
     key;
     #folder;
@@ -15,6 +16,9 @@ export class Variant extends AttachmentBase {
         this.#folder = attributes.folder;
         this.blurhash = attributes.blurhash;
     }
+    async generateBlurhash(options) {
+        this.blurhash = await imageToBlurhash(this.input, options);
+    }
     /**
      * Getters
      */

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, options }: ConverterInitializeAttributes);
-    save(): Promise<void>;
+    constructor({ record, attributeName, options, filters }: ConverterInitializeAttributes);
+    run(): Promise<void>;
 }

package/build/src/converter_manager.js

@@ -3,71 +3,93 @@ 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 { imageToBlurhash } from './utils/helpers.js';
+import { streamToTempFile } from './utils/helpers.js';
 export class ConverterManager {
     #record;
     #attributeName;
     #options;
-    constructor({ record, attributeName, options }) {
+    #filters;
+    constructor({ record, attributeName, options, filters }) {
         this.#record = record;
         this.#attributeName = attributeName;
         this.#options = options;
+        this.#filters = filters;
     }
-    async save() {
-        let attachments = this.#record.getAttachments({
+    async run() {
+        const attachments = this.#record.getAttachments({
             attributeName: this.#attributeName,
         });
-        const Model = this.#record.model.constructor;
-        const id = this.#record.model.$attributes['id'];
-        const data = {};
-        if (this.#options.variants) {
-            for await (const option of this.#options.variants) {
-                const converter = (await attachmentManager.getConverter(option));
-                if (attachments && converter) {
-                    for await (const attachment of attachments) {
-                        const input = attachment.input;
-                        const output = await converter.handle({
-                            input,
-                            options: converter.options,
-                        });
-                        if (output === undefined) {
-                            throw new errors.E_CANNOT_PATH_BY_CONVERTER();
-                        }
-                        const variant = await attachment.createVariant(option, output);
-                        if (converter.options.blurhash) {
-                            if ((typeof converter.options.blurhash !== 'boolean' &&
-                                converter.options.blurhash.enabled === true) ||
-                                converter.options.blurhash === true) {
-                                try {
-                                    const options = typeof converter.options.blurhash !== 'boolean'
-                                        ? converter.options.blurhash
-                                        : undefined;
-                                    variant.blurhash = await imageToBlurhash(variant.input, options);
-                                }
-                                catch (error) {
-                                    logger.error(error.message);
-                                }
-                            }
-                        }
-                        await attachmentManager.save(variant);
-                    }
+        const variants = [];
+        await this.#purge(attachments);
+        if (!attachments || !this.#options.variants || !this.#options.variants.length) {
+            return;
+        }
+        for await (const key of this.#options.variants) {
+            if (this.#filters?.variants !== undefined && !this.#filters?.variants?.includes(key)) {
+                continue;
+            }
+            const converter = (await attachmentManager.getConverter(key));
+            if (converter) {
+                for await (const attachment of attachments) {
+                    const variant = await this.#generate({
+                        key,
+                        attachment,
+                        converter
+                    });
+                    variants.push(variant);
                 }
             }
         }
-        if (Array.isArray(this.#record.model.$original[this.#attributeName])) {
-            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments.map((att) => att.toObject()));
+        return this.#commit(attachments, () => {
+            for (let i = 0; i < variants.length; i++) {
+                attachmentManager.remove(variants[i]);
+            }
+        });
+    }
+    async #generate({ key, attachment, converter }) {
+        let input = attachment.input;
+        if (!input) {
+            input = await streamToTempFile(await attachment.getStream());
         }
-        else {
-            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments[0].toObject());
+        const output = await converter.handle({
+            input,
+            options: converter.options,
+        });
+        if (output === undefined) {
+            throw new errors.E_CANNOT_PATH_BY_CONVERTER();
         }
-        const trx = await db.transaction();
-        trx.after('rollback', () => {
-            for (let i = 0; i < attachments.length; i++) {
-                for (const variant of attachments[i].variants) {
-                    attachmentManager.delete(variant);
+        const variant = await attachment.createVariant(key, output);
+        if (converter.options.blurhash) {
+            if ((typeof converter.options.blurhash !== 'boolean' &&
+                converter.options.blurhash.enabled === true) ||
+                converter.options.blurhash === true) {
+                try {
+                    const options = typeof converter.options.blurhash !== 'boolean'
+                        ? converter.options.blurhash
+                        : undefined;
+                    await variant.generateBlurhash(options);
+                }
+                catch (error) {
+                    logger.error(error.message);
                 }
             }
-        });
+        }
+        await attachmentManager.write(variant);
+        return variant;
+    }
+    async #commit(attachments, rollback) {
+        const Model = this.#record.row.constructor;
+        const id = this.#record.row.$attributes['id'];
+        const data = {};
+        const index = string.snakeCase(this.#attributeName);
+        if (Array.isArray(this.#record.row.$original[this.#attributeName])) {
+            data[index] = JSON.stringify(attachments.map((att) => att.toObject()));
+        }
+        else {
+            data[index] = JSON.stringify(attachments[0].toObject());
+        }
+        const trx = await db.transaction();
+        trx.after('rollback', rollback);
         try {
             await trx.query().from(Model.table).where('id', id).update(data);
             return trx.commit();
@@ -76,4 +98,22 @@ export class ConverterManager {
             return trx.rollback();
         }
     }
+    async #purge(attachments) {
+        return Promise.all(attachments.map(async (attachment) => {
+            if (attachment.variants) {
+                await Promise.all(attachment.variants.map(async (variant) => {
+                    if (this.#filters?.variants !== undefined && !this.#filters?.variants?.includes(variant.key)) {
+                        return;
+                    }
+                    return attachmentManager.remove(variant);
+                }));
+                if (this.#filters?.variants !== undefined) {
+                    attachment.variants = await attachment.variants.filter((variant) => !this.#filters?.variants?.includes(variant.key));
+                }
+                else {
+                    attachment.variants = [];
+                }
+            }
+        }));
+    }
 }

package/build/src/converters/autodetect_converter.d.ts

@@ -5,7 +5,8 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
 import Converter from './converter.js';
 export default class AutodetectConverter extends Converter {
-    handle({ input, options }: ConverterAttributes): Promise<false | import("../types/input.js").Input | undefined>;
+    handle({ input, options }: ConverterAttributes): Promise<Input | undefined>;
 }

package/build/src/converters/autodetect_converter.js

@@ -18,17 +18,15 @@ export default class AutodetectConverter extends Converter {
         else {
             fileType = await fileTypeFromFile(input);
         }
-        if (fileType?.mime.includes('image')) {
-            converter = new ImageConverter(options, this.binPaths);
-        }
-        else if (fileType?.mime.includes('video')) {
+        if (fileType?.mime.includes('video')) {
             converter = new VideoThumnailConverter(options, this.binPaths);
         }
-        if (converter) {
-            return await converter.handle({
-                input,
-                options,
-            });
+        else {
+            converter = new ImageConverter(options, this.binPaths);
         }
+        return converter.handle({
+            input,
+            options,
+        });
     }
 }

package/build/src/converters/video_thumbnail_converter.d.ts

@@ -8,6 +8,6 @@ import type { ConverterAttributes } from '../types/converter.js';
 import type { Input } from '../types/input.js';
 import Converter from './converter.js';
 export default class VideoThumbnailConvert extends Converter {
-    handle({ input, options }: ConverterAttributes): Promise<false | Input>;
-    videoToImage(ffmpeg: Function, input: Input): Promise<string | false>;
+    handle({ input, options }: ConverterAttributes): Promise<Input | undefined>;
+    videoToImage(ffmpeg: Function, input: Input): Promise<string | undefined>;
 }

package/build/src/converters/video_thumbnail_converter.js

@@ -16,7 +16,7 @@ export default class VideoThumbnailConvert extends Converter {
         const filePath = await this.videoToImage(ffmpeg, input);
         if (options && filePath) {
             const converter = new ImageConverter();
-            return await converter.handle({
+            return converter.handle({
                 input: filePath,
                 options,
             });

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

@@ -6,9 +6,9 @@
  */
 import type { LucidModel } from '@adonisjs/lucid/types/model';
 import type { LucidOptions } from '../types/attachment.js';
-import type { AttributeOfModelWithAttachment } from '../types/mixin.js';
+import type { AttributeOfRowWithAttachment } from '../types/mixin.js';
 export declare const bootModel: (model: LucidModel & {
-    $attachments: AttributeOfModelWithAttachment;
+    $attachments: AttributeOfRowWithAttachment;
 }) => 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/define_config.js

@@ -5,7 +5,6 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import { configProvider } from '@adonisjs/core';
-// export function defineConfig<T extends AttachmentConfig>(config: T): T {
 export function defineConfig(config) {
     return configProvider.create(async (_app) => {
         const convertersList = Object.keys(config.converters || {});
@@ -14,9 +13,14 @@ export function defineConfig(config) {
             for (let converterName of convertersList) {
                 const converter = config.converters[converterName];
                 const binConfig = config.bin;
-                const { default: value } = await converter.converter();
-                const Converter = value;
-                converters[converterName] = new Converter(converter.options, binConfig);
+                try {
+                    const { default: value } = await converter.converter();
+                    const Converter = value;
+                    converters[converterName] = new Converter(converter.options, binConfig);
+                }
+                catch (error) {
+                    console.error(`Failed to load converter ${converterName}:`, error);
+                }
             }
         }
         return {

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

@@ -1,9 +1,10 @@
-import type { ModelWithAttachment } from '../types/mixin.js';
+import type { RowWithAttachment } 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 {
+import type { RecordWithAttachment as RecordWithAttachmentImplementation } from '../types/service.js';
+import type { RegenerateOptions } from '../types/regenerate.js';
+export default class RecordWithAttachment implements RecordWithAttachmentImplementation {
     #private;
-    constructor(model: ModelWithAttachment);
+    constructor(row: RowWithAttachment);
     /**
      * During commit, we should cleanup the old detached files
      */
@@ -18,11 +19,13 @@ export default class Record implements RecordImplementation {
     }): Promise<void>;
     preComputeUrl(): Promise<void>;
     generateVariants(): Promise<void>;
+    regenerateVariants(options?: RegenerateOptions): Promise<void>;
     detach(): Promise<PromiseSettledResult<void>[]>;
     detachAll(): Promise<PromiseSettledResult<void>[]>;
-    get model(): ModelWithAttachment;
+    get row(): RowWithAttachment;
     getAttachments(options: {
         attributeName: string;
         requiredOriginal?: boolean;
+        requiredDirty?: boolean;
     }): AttachmentType[];
 }

package/build/src/services/record_with_attachment.js

@@ -4,33 +4,33 @@ 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) {
+export default class RecordWithAttachment {
+    #row;
+    constructor(row) {
+        this.#row = row;
+        if (!this.#row.$attachments) {
             /**
              * Empty previous $attachments
              */
-            this.#model.$attachments = structuredClone(defaultStateAttributeMixin);
+            this.#row.$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)));
+        await Promise.allSettled(this.#row.$attachments.detached.map((attachment) => attachmentManager.remove(attachment)));
     }
     /**
      * During rollback we should remove the attached files.
      */
     async rollback() {
-        await Promise.allSettled(this.#model.$attachments.attached.map((attachment) => attachmentManager.delete(attachment)));
+        await Promise.allSettled(this.#row.$attachments.attached.map((attachment) => attachmentManager.remove(attachment)));
     }
     async persist() {
         const attachmentAttributeNames = this.#getDirtyAttributeNamesOfAttachment();
         /**
-         * Persist attachments before saving the model to the database. This
+         * Persist attachments before saving the row to the database. This
          * way if file saving fails we will not write anything to the
          * database
          */
@@ -47,7 +47,7 @@ export default class Record {
             /**
              * memorise attribute name for generate variants
              */
-            this.#model.$attachments.dirtied.push(name);
+            this.#row.$attachments.dirtied.push(name);
             for (let i = 0; i < newAttachments.length; i++) {
                 if (originalAttachments.includes(newAttachments[i])) {
                     continue;
@@ -57,22 +57,22 @@ export default class Record {
                  * file.
                  */
                 if (newAttachments[i]) {
-                    newAttachments[i].setOptions(options).makeFolder(this.#model);
-                    this.#model.$attachments.attached.push(newAttachments[i]);
+                    newAttachments[i].setOptions(options).makeFolder(this.#row);
+                    this.#row.$attachments.attached.push(newAttachments[i]);
                     /**
                      * Also write the file to the disk right away
                      */
-                    await attachmentManager.save(newAttachments[i]);
+                    await attachmentManager.write(newAttachments[i]);
                 }
             }
         }));
     }
     async transaction(options = { enabledRollback: true }) {
         try {
-            if (this.#model.$trx) {
-                this.#model.$trx.after('commit', () => this.commit());
+            if (this.#row.$trx) {
+                this.#row.$trx.after('commit', () => this.commit());
                 if (options.enabledRollback) {
-                    this.#model.$trx.after('rollback', () => this.rollback());
+                    this.#row.$trx.after('rollback', () => this.rollback());
                 }
             }
             else {
@@ -90,7 +90,7 @@ export default class Record {
         const attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
         await Promise.all(attachmentAttributeNames.map(async (name) => {
             const options = this.#getOptionsByAttributeName(name);
-            if (this.#model.$attributes[name]) {
+            if (this.#row.$attributes[name]) {
                 const attachments = this.#getAttachmentsByAttributeName(name);
                 for (let i = 0; i < attachments.length; i++) {
                     attachments[i].setOptions(options);
@@ -100,8 +100,8 @@ export default class Record {
         }));
     }
     async generateVariants() {
-        /* this.#model.$dirty is not avalable in afterSave hooks */
-        const attachmentAttributeNames = this.#model.$attachments.dirtied;
+        /* this.#row.$dirty is not avalable in afterSave hooks */
+        const attachmentAttributeNames = this.#row.$attachments.dirtied;
         /**
          * For all properties Attachment
          * Launch async generation variants
@@ -109,7 +109,7 @@ export default class Record {
         for await (const name of attachmentAttributeNames) {
             const record = this;
             attachmentManager.queue.push({
-                name: `${this.#model.constructor.name}-${name}`,
+                name: `${this.#row.constructor.name}-${name}`,
                 async run() {
                     try {
                         const converterManager = new ConverterManager({
@@ -117,7 +117,38 @@ export default class Record {
                             attributeName: name,
                             options: record.#getOptionsByAttributeName(name),
                         });
-                        await converterManager.save();
+                        await converterManager.run();
+                    }
+                    catch (err) {
+                        throw new E_CANNOT_CREATE_VARIANT([err.message]);
+                    }
+                },
+            });
+        }
+    }
+    async regenerateVariants(options = {}) {
+        let attachmentAttributeNames;
+        if (options.attributes?.length) {
+            attachmentAttributeNames = options.attributes;
+        }
+        else {
+            attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
+        }
+        for await (const name of attachmentAttributeNames) {
+            const record = this;
+            attachmentManager.queue.push({
+                name: `${this.#row.constructor.name}-${name}`,
+                async run() {
+                    try {
+                        const converterManager = new ConverterManager({
+                            record,
+                            attributeName: name,
+                            options: record.#getOptionsByAttributeName(name),
+                            filters: {
+                                variants: options.variants
+                            }
+                        });
+                        await converterManager.run();
                     }
                     catch (err) {
                         throw new E_CANNOT_CREATE_VARIANT([err.message]);
@@ -134,7 +165,7 @@ export default class Record {
         return Promise.allSettled(attachmentAttributeNames.map((name) => {
             let attachments = [];
             const options = this.#getOptionsByAttributeName(name);
-            if (this.#model.$dirty[name] === null) {
+            if (this.#row.$dirty[name] === null) {
                 attachments = this.#getOriginalAttachmentsByAttributeName(name);
             }
             else {
@@ -158,7 +189,7 @@ export default class Record {
             }
             for (let i = 0; i < attachments.length; i++) {
                 attachments[i].setOptions(options);
-                this.#model.$attachments.detached.push(attachments[i]);
+                this.#row.$attachments.detached.push(attachments[i]);
             }
         }));
     }
@@ -172,53 +203,68 @@ export default class Record {
             const attachments = this.#getAttachmentsByAttributeName(name);
             for (let i = 0; i < attachments.length; i++) {
                 attachments[i].setOptions(options);
-                this.#model.$attachments.detached.push(attachments[i]);
+                this.#row.$attachments.detached.push(attachments[i]);
             }
         }));
     }
-    get model() {
-        return this.#model;
+    get row() {
+        return this.#row;
     }
     getAttachments(options) {
+        let attachments;
         if (options.requiredOriginal) {
-            return this.#getOriginalAttachmentsByAttributeName(options.attributeName);
+            attachments = this.#getOriginalAttachmentsByAttributeName(options.attributeName);
+        }
+        else if (options.requiredDirty) {
+            attachments = this.#getDirtyAttachmentsByAttributeName(options.attributeName);
         }
         else {
-            return this.#getAttachmentsByAttributeName(options.attributeName);
+            attachments = this.#getAttachmentsByAttributeName(options.attributeName);
         }
+        const opts = this.#getOptionsByAttributeName(options.attributeName);
+        attachments.map((attachment) => attachment.setOptions(opts).makeFolder(this.#row));
+        return attachments;
     }
     #getAttachmentsByAttributeName(name) {
-        if (Array.isArray(this.#model.$attributes[name])) {
-            return this.#model.$attributes[name];
+        if (Array.isArray(this.#row.$attributes[name])) {
+            return this.#row.$attributes[name];
         }
-        return [this.#model.$attributes[name]];
+        return [this.#row.$attributes[name]];
     }
     #getOriginalAttachmentsByAttributeName(name) {
-        if (Array.isArray(this.#model.$original[name])) {
-            return this.#model.$original[name];
+        if (Array.isArray(this.#row.$original[name])) {
+            return this.#row.$original[name];
+        }
+        return [this.#row.$original[name]];
+    }
+    #getDirtyAttachmentsByAttributeName(name) {
+        if (Array.isArray(this.#row.$dirty[name])) {
+            return this.#row.$dirty[name];
         }
-        return [this.#model.$original[name]];
+        return [this.#row.$dirty[name]];
     }
     #getOptionsByAttributeName(name) {
-        return this.#model.constructor.prototype[optionsSym]?.[name];
+        return this.#row.constructor.prototype[optionsSym]?.[name];
     }
     #getAttributeNamesOfAttachment() {
-        return Object.keys(this.#model.$attributes).filter((name) => {
-            const value = this.#model.$attributes[name];
+        return Object.keys(this.#row.$attributes).filter((name) => {
+            const value = this.#row.$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
+        return Object.keys(this.#row.$dirty).filter((name) => {
+            const dirtyValue = this.#row.$dirty[name];
+            const originalValue = this.#row.$original[name]; // if dirtyValue is null, check original type
             const isDirtyAttachment = dirtyValue instanceof Attachment ||
                 (Array.isArray(dirtyValue) &&
-                    dirtyValue.every((item) => item instanceof Attachment) &&
-                    dirtyValue.length);
+                    dirtyValue.length &&
+                    dirtyValue.every((item) => item instanceof Attachment));
             const isOriginalAttachment = originalValue instanceof Attachment ||
-                (Array.isArray(originalValue) && originalValue.every((item) => item instanceof Attachment));
+                (Array.isArray(originalValue) &&
+                    originalValue.length &&
+                    originalValue.every((item) => item instanceof Attachment));
             return isDirtyAttachment || isOriginalAttachment;
         });
     }

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

@@ -10,6 +10,7 @@ import type { Exif, Input } from './input.js';
 import type { Disk } from '@adonisjs/drive';
 import type { SignedURLOptions } from '@adonisjs/drive/types';
 import type { AttachmentVariants } from '@jrmc/adonis-attachment';
+import { BlurhashOptions } from './converter.js';
 export type AttachmentBase = {
     drive: DriveService;
     input?: Input;
@@ -25,6 +26,7 @@ export type AttachmentBase = {
     options: LucidOptions;
     makeFolder(record?: LucidRow): void;
     getDisk(): Disk;
+    getStream(): Promise<NodeJS.ReadableStream>;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): AttachmentBase;
@@ -44,6 +46,7 @@ export type Variant = AttachmentBase & {
     key: string;
     folder: string;
     blurhash?: string;
+    generateBlurhash(options?: BlurhashOptions): void;
     toObject(): VariantAttributes;
 };
 export type LucidOptions = {

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

@@ -4,8 +4,8 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import { ConfigProvider } from '@adonisjs/core/types';
 import type { Converter, ConverterOptions } from './converter.js';
+import { ConfigProvider } from '@adonisjs/core/types';
 import { AttachmentManager } from '../attachment_manager.js';
 type ImportConverter = {
     default: unknown;

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

@@ -4,7 +4,7 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import type { Record } from './service.js';
+import type { RecordWithAttachment } from './service.js';
 import type { BinPaths } from './config.js';
 import type { Input } from './input.js';
 import type { LucidOptions } from './attachment.js';
@@ -14,9 +14,12 @@ export type Converter = {
     handle?: (attributes: ConverterAttributes) => Promise<Input | undefined>;
 };
 export type ConverterInitializeAttributes = {
-    record: Record;
+    record: RecordWithAttachment;
     attributeName: string;
     options: LucidOptions;
+    filters?: {
+        variants?: string[];
+    };
 };
 export type ConverterAttributes = {
     input: Input;

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

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

package/build/src/types/index.js

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

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

@@ -6,11 +6,11 @@
  */
 import type { LucidRow } from '@adonisjs/lucid/types/model';
 import type { Attachment } from './attachment.js';
-export type AttributeOfModelWithAttachment = {
+export type AttributeOfRowWithAttachment = {
     attached: Attachment[];
     detached: Attachment[];
     dirtied: string[];
 };
-export type ModelWithAttachment = LucidRow & {
-    $attachments: AttributeOfModelWithAttachment;
+export type RowWithAttachment = LucidRow & {
+    $attachments: AttributeOfRowWithAttachment;
 };

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

@@ -0,0 +1,5 @@
+import type { AttachmentVariants } from '@jrmc/adonis-attachment';
+export type RegenerateOptions = {
+    attributes?: string[];
+    variants?: (keyof AttachmentVariants)[];
+};

package/build/src/types/regenerate.js

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

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

@@ -1,7 +1,7 @@
 import type { Attachment } from './attachment.js';
-import type { ModelWithAttachment } from './mixin.js';
-export interface Record {
-    model: ModelWithAttachment;
+import type { RowWithAttachment } from './mixin.js';
+export interface RecordWithAttachment {
+    row: RowWithAttachment;
     commit(): Promise<void>;
     rollback(): Promise<void>;
     persist(): Promise<void>;
@@ -13,5 +13,6 @@ export interface Record {
     getAttachments(options: {
         attributeName: string;
         requiredOriginal?: boolean;
+        requiredDirty?: boolean;
     }): Attachment[];
 }

package/build/src/utils/hooks.js

@@ -4,11 +4,11 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import Record from '../services/record_with_attachment.js';
+import RecordWithAttachment from '../services/record_with_attachment.js';
 // @afterFind()
 export const afterFindHook = async (instance) => {
     const modelInstance = instance;
-    const model = new Record(modelInstance);
+    const model = new RecordWithAttachment(modelInstance);
     await model.preComputeUrl();
 };
 // @afterFetch()
@@ -20,7 +20,7 @@ export const afterFetchHook = async (instance) => {
 // @beforeSave()
 export const beforeSaveHook = async (instance) => {
     const modelInstance = instance;
-    const model = new Record(modelInstance);
+    const model = new RecordWithAttachment(modelInstance);
     await model.detach();
     await model.persist();
     await model.transaction();
@@ -28,13 +28,13 @@ export const beforeSaveHook = async (instance) => {
 // @afterSave()
 export const afterSaveHook = async (instance) => {
     const modelInstance = instance;
-    const model = new Record(modelInstance);
+    const model = new RecordWithAttachment(modelInstance);
     await model.generateVariants();
 };
 // @beforeDelete()
 export const beforeDeleteHook = async (instance) => {
     const modelInstance = instance;
-    const model = new Record(modelInstance);
+    const model = new RecordWithAttachment(modelInstance);
     await model.detachAll();
     await model.transaction({ enabledRollback: false });
 };

package/package.json

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

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

@@ -1,151 +0,0 @@
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */
-import type { BaseModel } from '@adonisjs/lucid/orm';
-import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import type { AttributeOfModelWithAttachment } from '../types/mixin.js';
-type Constructor = NormalizeConstructor<typeof BaseModel>;
-export declare function Attachmentable<T extends Constructor>(superclass: T): {
-    new (...args: any[]): {
-        $attachments: AttributeOfModelWithAttachment;
-        $attributes: import("@adonisjs/lucid/types/model").ModelObject;
-        $extras: import("@adonisjs/lucid/types/model").ModelObject;
-        $original: import("@adonisjs/lucid/types/model").ModelObject;
-        $preloaded: {
-            [relation: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
-        };
-        $columns: undefined;
-        $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
-        $primaryKeyValue?: number | string;
-        $isPersisted: boolean;
-        $isNew: boolean;
-        $isLocal: boolean;
-        $dirty: import("@adonisjs/lucid/types/model").ModelObject;
-        $isDirty: boolean;
-        $isDeleted: boolean;
-        $options?: import("@adonisjs/lucid/types/model").ModelOptions;
-        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract;
-        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): void;
-        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
-        useConnection(connection: string): /*elided*/ any;
-        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
-        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel>;
-        $setAttribute(key: string, value: any): void;
-        $getAttribute(key: string): any;
-        $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
-        $hasRelated(key: string): boolean;
-        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
-        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
-        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | undefined | null;
-        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
-        $hydrateOriginals(): void;
-        fill(value: Partial<{
-            $attachments: AttributeOfModelWithAttachment;
-        }>, allowExtraProperties?: boolean): /*elided*/ any;
-        merge(value: Partial<{
-            $attachments: AttributeOfModelWithAttachment;
-        }>, allowExtraProperties?: boolean): /*elided*/ any;
-        isDirty(fields?: "$attachments" | ("$attachments" | undefined)[] | undefined): boolean;
-        enableForceUpdate(): /*elided*/ any;
-        save(): Promise</*elided*/ any>;
-        lockForUpdate<T_1>(callback: (user: /*elided*/ any) => T_1 | Promise<T_1>): Promise<T_1>;
-        delete(): Promise<void>;
-        refresh(): Promise</*elided*/ any>;
-        load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
-        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
-        preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
-        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
-        loadCount: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
-        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
-        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
-        serializeRelations(fields: undefined, raw: true): {
-            [key: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
-        };
-        serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
-        serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
-        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
-        toObject(): import("@adonisjs/lucid/types/model").ModelObject;
-        toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
-        related<Name extends undefined>(relation: Name): /*elided*/ any[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? /*elided*/ any[Name]["client"] : never;
-    };
-    warn(): Promise<void>;
-    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;
-    $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
-    $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
-    $computedDefinitions: Map<string, import("@adonisjs/lucid/types/model").ComputedOptions>;
-    primaryKey: string;
-    connection?: string | undefined;
-    table: string;
-    selfAssignPrimaryKey: boolean;
-    $adapter: import("@adonisjs/lucid/types/model").AdapterContract;
-    useAdapter: (adapter: import("@adonisjs/lucid/types/model").AdapterContract) => void;
-    $hooks: import("@poppinss/hooks").default<any>;
-    $keys: {
-        attributesToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
-        attributesToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
-        columnsToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
-        columnsToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
-        serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
-        serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
-    };
-    $createFromAdapterResult: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T_1>;
-    $createMultipleFromAdapterResult: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T_1>[];
-    $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
-    $hasColumn: (name: string) => boolean;
-    $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
-    $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
-    $hasComputed: (name: string) => boolean;
-    $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
-    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
-    $hasRelation: (name: string) => boolean;
-    $getRelation: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model>>>(this: Model, name: Name): InstanceType<Model>[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? InstanceType<Model>[Name]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
-    };
-    $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): 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").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;
-    };
-    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: {
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T_1>>;
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T_1>>;
-    };
-    findByOrFail: {
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>>;
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>>;
-    };
-    findManyBy: {
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>[]>;
-        <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T_1>[]>;
-    };
-    first: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T_1>>;
-    firstOrFail: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T_1>>;
-    findMany: <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>[]>;
-    firstOrNew: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
-    firstOrCreate: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
-    updateOrCreate: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>>;
-    fetchOrNewUpMany: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
-    fetchOrCreateMany: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
-    updateOrCreateMany: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_1>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T_1>[]>;
-    query: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model>>(this: Model, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model, Result>;
-    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
-    truncate: (cascade?: boolean) => Promise<void>;
-} & T;
-export {};

package/build/src/mixins/attachmentable.js

@@ -1,31 +0,0 @@
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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, beforeFind, beforeFetch, beforePaginate, beforeCreate, } from '@adonisjs/lucid/orm';
-import { defaultStateAttributeMixin } from '../utils/default_values.js';
-import logger from '@adonisjs/core/services/logger';
-export function Attachmentable(superclass) {
-    class ModelWithAttachment extends superclass {
-        $attachments = structuredClone(defaultStateAttributeMixin);
-        static async warn() {
-            logger.warn(`The "Attachmentable" mixin is deprecated and may be removed in a future version.`);
-        }
-    }
-    __decorate([
-        beforeCreate(),
-        beforeFind(),
-        beforeFetch(),
-        beforePaginate(),
-        beforeSave()
-    ], ModelWithAttachment, "warn", null);
-    return ModelWithAttachment;
-}