@jrmc/adonis-attachment 5.0.0-beta.3 → 5.0.0-beta.6

package/build/src/services/attachment/attachment_persister_service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { RecordWithAttachment as RecordWithAttachmentImplementation } from '../../types/service.js';
+export declare class AttachmentPersisterService {
+    /**
+     * Persist attachments before saving the row to the database
+     */
+    persistAttachments(record: RecordWithAttachmentImplementation): Promise<void>;
+    /**
+     * Pre-compute URLs for all attachments
+     */
+    preComputeUrls(record: RecordWithAttachmentImplementation): Promise<void>;
+    /**
+     * Set key IDs for all attachments using encryption
+     */
+    setKeyIds(record: RecordWithAttachmentImplementation): Promise<void>;
+}
+//# sourceMappingURL=attachment_persister_service.d.ts.map

package/build/src/services/attachment/attachment_persister_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_persister_service.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/attachment_persister_service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,oBAAoB,IAAI,kCAAkC,EAAE,MAAM,wBAAwB,CAAA;AAKxG,qBAAa,0BAA0B;IACrC;;OAEG;IACG,kBAAkB,CAAC,MAAM,EAAE,kCAAkC,GAAG,OAAO,CAAC,IAAI,CAAC;IA8CnF;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,kCAAkC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB/E;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,kCAAkC,GAAG,OAAO,CAAC,IAAI,CAAC;CA4B3E"}

package/build/src/services/attachment/attachment_persister_service.js

@@ -0,0 +1,95 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import encryption from '@adonisjs/core/services/encryption';
+import attachmentManager from '../../../services/main.js';
+import { AttachmentUtils } from './attachment_utils.js';
+export class AttachmentPersisterService {
+    /**
+     * Persist attachments before saving the row to the database
+     */
+    async persistAttachments(record) {
+        const attachmentAttributeNames = AttachmentUtils.getDirtyAttributeNamesOfAttachment(record.row);
+        await Promise.all(attachmentAttributeNames.map(async (name) => {
+            const originalAttachments = AttachmentUtils.getOriginalAttachmentsByAttributeName(record.row, name);
+            const newAttachments = AttachmentUtils.getAttachmentsByAttributeName(record.row, name);
+            const options = AttachmentUtils.getOptionsByAttributeName(record.row, name);
+            /**
+             * Skip when the attachment attributeName hasn't been updated
+             */
+            if (!originalAttachments && !newAttachments) {
+                return;
+            }
+            /**
+             * memorise attribute name for generate variants
+             */
+            record.row.$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);
+                    await newAttachments[i].makeFolder(record.row);
+                    await newAttachments[i].makeName(record.row, name, newAttachments[i].originalName);
+                    record.row.$attachments.attached.push(newAttachments[i]);
+                    /**
+                     * Also write the file to the disk right away
+                     */
+                    await attachmentManager.write(newAttachments[i]);
+                }
+            }
+        }));
+    }
+    /**
+     * Pre-compute URLs for all attachments
+     */
+    async preComputeUrls(record) {
+        const attachmentAttributeNames = AttachmentUtils.getAttributeNamesOfAttachment(record.row);
+        await Promise.all(attachmentAttributeNames.map(async (name) => {
+            const options = AttachmentUtils.getOptionsByAttributeName(record.row, name);
+            if (record.row.$attributes[name]) {
+                const attachments = AttachmentUtils.getAttachmentsByAttributeName(record.row, name);
+                for (let i = 0; i < attachments.length; i++) {
+                    attachments[i].setOptions(options);
+                    await attachmentManager.preComputeUrl(attachments[i]);
+                }
+            }
+        }));
+    }
+    /**
+     * Set key IDs for all attachments using encryption
+     */
+    async setKeyIds(record) {
+        const attachmentAttributeNames = AttachmentUtils.getAttributeNamesOfAttachment(record.row);
+        await Promise.all(attachmentAttributeNames.map(async (name) => {
+            if (record.row.$attributes[name]) {
+                const attachments = AttachmentUtils.getAttachmentsByAttributeName(record.row, name);
+                for (let i = 0; i < attachments.length; i++) {
+                    const { disk, folder, meta, rename } = attachments[i].options;
+                    const model = record.row.constructor;
+                    const key = encryption.encrypt({
+                        model: model.table,
+                        id: record.row.$attributes['id'],
+                        attribute: name,
+                        index: i,
+                        options: {
+                            disk,
+                            folder,
+                            meta,
+                            rename
+                        }
+                    });
+                    attachments[i].setKeyId(key);
+                }
+            }
+        }));
+    }
+}

package/build/src/services/attachment/attachment_recorder_service.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { RowWithAttachment } from '../../types/mixin.js';
+import type { Attachment as AttachmentType } from '../../types/attachment.js';
+import type { RecordWithAttachment as RecordWithAttachmentImplementation } from '../../types/service.js';
+import type { RegenerateOptions } from '../../types/regenerate.js';
+import type { TransactionOptions } from './attachment_transaction_service.js';
+export default class AttachmentRecorderService implements RecordWithAttachmentImplementation {
+    #private;
+    constructor(row: RowWithAttachment);
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    commit(): Promise<void>;
+    /**
+     * During rollback we should remove the attached files.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Persist attachments before saving the row to the database
+     */
+    persist(): Promise<void>;
+    /**
+     * Handle transaction lifecycle
+     */
+    transaction(options?: TransactionOptions): Promise<void>;
+    /**
+     * Pre-compute URLs for all attachments
+     */
+    preComputeUrl(): Promise<void>;
+    /**
+     * Set key IDs for all attachments
+     */
+    setKeyId(): Promise<void>;
+    /**
+     * Generate variants for all dirty attachment attributes
+     */
+    generateVariants(): Promise<void>;
+    /**
+     * Regenerate variants with specific options
+     */
+    regenerateVariants(options?: RegenerateOptions): Promise<void>;
+    /**
+     * Detach dirty attachments (mark for deletion)
+     */
+    detach(): Promise<void>;
+    /**
+     * Detach all attachments (mark all for deletion)
+     */
+    detachAll(): Promise<void>;
+    /**
+     * Get row instance
+     */
+    get row(): RowWithAttachment;
+    /**
+     * Get attachments with specific options
+     */
+    getAttachments(options: {
+        attributeName: string;
+        requiredOriginal?: boolean;
+        requiredDirty?: boolean;
+    }): Promise<AttachmentType[]>;
+}
+//# sourceMappingURL=attachment_recorder_service.d.ts.map

package/build/src/services/attachment/attachment_recorder_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_recorder_service.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/attachment_recorder_service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,EAAE,oBAAoB,IAAI,kCAAkC,EAAE,MAAM,wBAAwB,CAAA;AACxG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AAS7E,MAAM,CAAC,OAAO,OAAO,yBAA0B,YAAW,kCAAkC;;gBAO9E,GAAG,EAAE,iBAAiB;IAclC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;OAEG;IACG,WAAW,CAAC,OAAO,GAAE,kBAA8C,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzF;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAIpC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvC;;OAEG;IACG,kBAAkB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxE;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC;;OAEG;IACH,IAAI,GAAG,IAAI,iBAAiB,CAE3B;IAED;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE;QAC5B,aAAa,EAAE,MAAM,CAAA;QACrB,gBAAgB,CAAC,EAAE,OAAO,CAAA;QAC1B,aAAa,CAAC,EAAE,OAAO,CAAA;KACxB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;CAsB9B"}

package/build/src/services/attachment/attachment_recorder_service.js

@@ -0,0 +1,121 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { defaultStateAttributeMixin } from '../../utils/default_values.js';
+import { AttachmentTransactionService } from './attachment_transaction_service.js';
+import { AttachmentPersisterService } from './attachment_persister_service.js';
+import { AttachmentVariantService } from './attachment_variant_service.js';
+import { AttachmentDetachmentService } from './attachment_detachment_service.js';
+import { AttachmentUtils } from './attachment_utils.js';
+export default class AttachmentRecorderService {
+    #row;
+    #transactionService = new AttachmentTransactionService();
+    #persistenceService = new AttachmentPersisterService();
+    #variantService = new AttachmentVariantService();
+    #detachmentService = new AttachmentDetachmentService();
+    constructor(row) {
+        this.#row = row;
+        this.#initializeAttachments();
+    }
+    /**
+     * Initialize attachments state if not exists
+     */
+    #initializeAttachments() {
+        if (!this.#row.$attachments) {
+            this.#row.$attachments = structuredClone(defaultStateAttributeMixin);
+        }
+    }
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    async commit() {
+        await this.#transactionService.commit(this.#row.$attachments.detached);
+    }
+    /**
+     * During rollback we should remove the attached files.
+     */
+    async rollback() {
+        await this.#transactionService.rollback(this.#row.$attachments.attached);
+    }
+    /**
+     * Persist attachments before saving the row to the database
+     */
+    async persist() {
+        await this.#persistenceService.persistAttachments(this);
+    }
+    /**
+     * Handle transaction lifecycle
+     */
+    async transaction(options = { enabledRollback: true }) {
+        await this.#transactionService.handleTransaction(this, options);
+    }
+    /**
+     * Pre-compute URLs for all attachments
+     */
+    async preComputeUrl() {
+        await this.#persistenceService.preComputeUrls(this);
+    }
+    /**
+     * Set key IDs for all attachments
+     */
+    async setKeyId() {
+        await this.#persistenceService.setKeyIds(this);
+    }
+    /**
+     * Generate variants for all dirty attachment attributes
+     */
+    async generateVariants() {
+        await this.#variantService.generateVariants(this);
+    }
+    /**
+     * Regenerate variants with specific options
+     */
+    async regenerateVariants(options = {}) {
+        await this.#variantService.regenerateVariants(this, options);
+    }
+    /**
+     * Detach dirty attachments (mark for deletion)
+     */
+    async detach() {
+        await this.#detachmentService.detach(this);
+    }
+    /**
+     * Detach all attachments (mark all for deletion)
+     */
+    async detachAll() {
+        await this.#detachmentService.detachAll(this);
+    }
+    /**
+     * Get row instance
+     */
+    get row() {
+        return this.#row;
+    }
+    /**
+     * Get attachments with specific options
+     */
+    async getAttachments(options) {
+        let attachments;
+        if (options.requiredOriginal) {
+            attachments = AttachmentUtils.getOriginalAttachmentsByAttributeName(this.#row, options.attributeName);
+        }
+        else if (options.requiredDirty) {
+            attachments = AttachmentUtils.getDirtyAttachmentsByAttributeName(this.#row, options.attributeName);
+        }
+        else {
+            attachments = AttachmentUtils.getAttachmentsByAttributeName(this.#row, options.attributeName);
+        }
+        const opts = AttachmentUtils.getOptionsByAttributeName(this.#row, options.attributeName);
+        attachments.forEach(async (attachment) => {
+            if (attachment) {
+                attachment.setOptions(opts);
+                await attachment.makeFolder(this.#row);
+                // await attachment.makeName(this.#row, options.attributeName, attachment.originalName)
+            }
+        });
+        return attachments;
+    }
+}

package/build/src/services/attachment/attachment_transaction_service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { Attachment as AttachmentType } from '../../types/attachment.js';
+import type { RecordWithAttachment as RecordWithAttachmentImplementation } from '../../types/service.js';
+export interface TransactionOptions {
+    enabledRollback?: boolean;
+}
+export declare class AttachmentTransactionService {
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    commit(detachedAttachments: AttachmentType[]): Promise<void>;
+    /**
+     * During rollback we should remove the attached files.
+     */
+    rollback(attachedAttachments: AttachmentType[]): Promise<void>;
+    /**
+     * Handle transaction lifecycle with commit and rollback hooks
+     */
+    handleTransaction(record: RecordWithAttachmentImplementation, options?: TransactionOptions): Promise<void>;
+}
+//# sourceMappingURL=attachment_transaction_service.d.ts.map

package/build/src/services/attachment/attachment_transaction_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_transaction_service.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/attachment_transaction_service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,EAAE,oBAAoB,IAAI,kCAAkC,EAAE,MAAM,wBAAwB,CAAA;AAGxG,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,qBAAa,4BAA4B;IACvC;;OAEG;IACG,MAAM,CAAC,mBAAmB,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlE;;OAEG;IACG,QAAQ,CAAC,mBAAmB,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IASpE;;OAEG;IACG,iBAAiB,CACrB,MAAM,EAAE,kCAAkC,EAC1C,OAAO,GAAE,kBAA8C,GACtD,OAAO,CAAC,IAAI,CAAC;CAiBjB"}

package/build/src/services/attachment/attachment_transaction_service.js

@@ -0,0 +1,46 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import attachmentManager from '../../../services/main.js';
+export class AttachmentTransactionService {
+    /**
+     * During commit, we should cleanup the old detached files
+     */
+    async commit(detachedAttachments) {
+        await Promise.allSettled(detachedAttachments.map((attachment) => attachmentManager.remove(attachment)));
+    }
+    /**
+     * During rollback we should remove the attached files.
+     */
+    async rollback(attachedAttachments) {
+        await Promise.allSettled(attachedAttachments.map(async (attachment) => {
+            await attachment.rollbackMoveFileForDelete();
+            await attachmentManager.remove(attachment);
+        }));
+    }
+    /**
+     * Handle transaction lifecycle with commit and rollback hooks
+     */
+    async handleTransaction(record, options = { enabledRollback: true }) {
+        try {
+            if (record.row.$trx) {
+                record.row.$trx.after('commit', () => this.commit(record.row.$attachments.detached));
+                if (options.enabledRollback) {
+                    record.row.$trx.after('rollback', () => this.rollback(record.row.$attachments.attached));
+                }
+            }
+            else {
+                await this.commit(record.row.$attachments.detached);
+            }
+        }
+        catch (error) {
+            if (options.enabledRollback) {
+                await this.rollback(record.row.$attachments.attached);
+            }
+            throw error;
+        }
+    }
+}

package/build/src/services/attachment/attachment_utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { RowWithAttachment } from '../../types/mixin.js';
+import type { Attachment as AttachmentType, LucidOptions } from '../../types/attachment.js';
+export declare class AttachmentUtils {
+    /**
+     * Get attachments by attribute name, handling both single and array values
+     */
+    static getAttachmentsByAttributeName(row: RowWithAttachment, name: string): AttachmentType[];
+    /**
+     * Get original attachments by attribute name, handling both single and array values
+     */
+    static getOriginalAttachmentsByAttributeName(row: RowWithAttachment, name: string): AttachmentType[];
+    /**
+     * Get dirty attachments by attribute name, handling both single and array values
+     */
+    static getDirtyAttachmentsByAttributeName(row: RowWithAttachment, name: string): AttachmentType[];
+    /**
+     * Get options by attribute name from the model prototype
+     */
+    static getOptionsByAttributeName(row: RowWithAttachment, name: string): LucidOptions;
+    /**
+     * Get all attribute names that contain attachments
+     */
+    static getAttributeNamesOfAttachment(row: RowWithAttachment): string[];
+    /**
+     * Get dirty attribute names that contain attachments
+     */
+    static getDirtyAttributeNamesOfAttachment(row: RowWithAttachment): string[];
+}
+//# sourceMappingURL=attachment_utils.d.ts.map

package/build/src/services/attachment/attachment_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_utils.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/attachment_utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAI3F,qBAAa,eAAe;IAC1B;;OAEG;IACH,MAAM,CAAC,6BAA6B,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE;IAO5F;;OAEG;IACH,MAAM,CAAC,qCAAqC,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE;IAOpG;;OAEG;IACH,MAAM,CAAC,kCAAkC,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE;IAOjG;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY;IAIpF;;OAEG;IACH,MAAM,CAAC,6BAA6B,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,EAAE;IAUtE;;OAEG;IACH,MAAM,CAAC,kCAAkC,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,EAAE;CAoB5E"}

package/build/src/services/attachment/attachment_utils.js

@@ -0,0 +1,71 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { Attachment } from '../../attachments/attachment.js';
+import { optionsSym } from '../../utils/symbols.js';
+export class AttachmentUtils {
+    /**
+     * Get attachments by attribute name, handling both single and array values
+     */
+    static getAttachmentsByAttributeName(row, name) {
+        if (Array.isArray(row.$attributes[name])) {
+            return row.$attributes[name];
+        }
+        return [row.$attributes[name]];
+    }
+    /**
+     * Get original attachments by attribute name, handling both single and array values
+     */
+    static getOriginalAttachmentsByAttributeName(row, name) {
+        if (Array.isArray(row.$original[name])) {
+            return row.$original[name];
+        }
+        return [row.$original[name]];
+    }
+    /**
+     * Get dirty attachments by attribute name, handling both single and array values
+     */
+    static getDirtyAttachmentsByAttributeName(row, name) {
+        if (Array.isArray(row.$dirty[name])) {
+            return row.$dirty[name];
+        }
+        return [row.$dirty[name]];
+    }
+    /**
+     * Get options by attribute name from the model prototype
+     */
+    static getOptionsByAttributeName(row, name) {
+        return row.constructor.prototype[optionsSym]?.[name];
+    }
+    /**
+     * Get all attribute names that contain attachments
+     */
+    static getAttributeNamesOfAttachment(row) {
+        return Object.keys(row.$attributes).filter((name) => {
+            const value = row.$attributes[name];
+            return (value instanceof Attachment ||
+                (Array.isArray(value) && value.every((item) => item instanceof Attachment)));
+        });
+    }
+    /**
+     * Get dirty attribute names that contain attachments
+     */
+    static getDirtyAttributeNamesOfAttachment(row) {
+        return Object.keys(row.$dirty).filter((name) => {
+            const dirtyValue = row.$dirty[name];
+            const originalValue = row.$original[name]; // if dirtyValue is null, check original type
+            const isDirtyAttachment = dirtyValue instanceof Attachment ||
+                (Array.isArray(dirtyValue) &&
+                    dirtyValue.length &&
+                    dirtyValue.every((item) => item instanceof Attachment));
+            const isOriginalAttachment = originalValue instanceof Attachment ||
+                (Array.isArray(originalValue) &&
+                    originalValue.length &&
+                    originalValue.every((item) => item instanceof Attachment));
+            return isDirtyAttachment || isOriginalAttachment;
+        });
+    }
+}

package/build/src/services/attachment/attachment_variant_service.d.ts

@@ -0,0 +1,17 @@
+import type { RecordWithAttachment as RecordWithAttachmentImplementation } from '../../types/service.js';
+import type { RegenerateOptions } from '../../types/regenerate.js';
+export interface VariantOptions {
+    variants?: string[];
+}
+export declare class AttachmentVariantService {
+    #private;
+    /**
+     * Generate variants for all dirty attachment attributes
+     */
+    generateVariants(record: RecordWithAttachmentImplementation): Promise<void>;
+    /**
+     * Regenerate variants with specific options
+     */
+    regenerateVariants(record: RecordWithAttachmentImplementation, options?: RegenerateOptions): Promise<void>;
+}
+//# sourceMappingURL=attachment_variant_service.d.ts.map

package/build/src/services/attachment/attachment_variant_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_variant_service.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/attachment_variant_service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,IAAI,kCAAkC,EAAE,MAAM,wBAAwB,CAAA;AACxG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAOlE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,qBAAa,wBAAwB;;IACnC;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,kCAAkC,GAAG,OAAO,CAAC,IAAI,CAAC;IAajF;;OAEG;IACG,kBAAkB,CACtB,MAAM,EAAE,kCAAkC,EAC1C,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC;CAyDjB"}

package/build/src/services/attachment/attachment_variant_service.js

@@ -0,0 +1,72 @@
+import logger from '@adonisjs/core/services/logger';
+import attachmentManager from '../../../services/main.js';
+import VariantService from '../variant_service.js';
+import { AttachmentUtils } from './attachment_utils.js';
+import { E_CANNOT_CREATE_VARIANT } from '../../errors.js';
+export class AttachmentVariantService {
+    /**
+     * Generate variants for all dirty attachment attributes
+     */
+    async generateVariants(record) {
+        /* this.#row.$dirty is not available in afterSave hooks */
+        const attachmentAttributeNames = record.row.$attachments.dirtied;
+        for await (const name of attachmentAttributeNames) {
+            if (!record.row.$attributes[name]) {
+                continue;
+            }
+            this.#queueVariantGeneration(name, record, {});
+        }
+    }
+    /**
+     * Regenerate variants with specific options
+     */
+    async regenerateVariants(record, options = {}) {
+        let attachmentAttributeNames;
+        if (options.attributes?.length) {
+            attachmentAttributeNames = options.attributes;
+        }
+        else {
+            attachmentAttributeNames = AttachmentUtils.getAttributeNamesOfAttachment(record.row);
+        }
+        for await (const name of attachmentAttributeNames) {
+            if (!record.row.$attributes[name]) {
+                continue;
+            }
+            this.#queueVariantGeneration(name, record, { variants: options.variants });
+        }
+    }
+    /**
+     * Queue variant generation with error handling
+     */
+    #queueVariantGeneration(name, record, options) {
+        attachmentManager.queue.push({
+            name: `${record.row.constructor.name}-${name}`,
+            async run() {
+                const model = record.row.constructor;
+                await attachmentManager.lock.createLock(`attachment.${model.table}-${name}`).run(async () => {
+                    const variantService = new VariantService({
+                        record,
+                        attributeName: name,
+                        options: AttachmentUtils.getOptionsByAttributeName(record.row, name),
+                        filters: {
+                            variants: options.variants
+                        }
+                    });
+                    await variantService.run();
+                });
+            },
+        })
+            .onError = (error) => this.#handleVariantError(error);
+    }
+    /**
+     * Handle variant generation errors
+     */
+    #handleVariantError(error) {
+        if (error.message) {
+            logger.error(error.message);
+        }
+        else {
+            throw new E_CANNOT_CREATE_VARIANT([error]);
+        }
+    }
+}

package/build/src/services/attachment/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export { default as AttachmentRecordService } from './attachment_recorder_service.js';
+export { AttachmentTransactionService } from './attachment_transaction_service.js';
+export { AttachmentPersisterService } from './attachment_persister_service.js';
+export { AttachmentVariantService } from './attachment_variant_service.js';
+export { AttachmentDetachmentService } from './attachment_detachment_service.js';
+export { AttachmentUtils } from './attachment_utils.js';
+export type { TransactionOptions } from './attachment_transaction_service.js';
+export type { VariantOptions } from './attachment_variant_service.js';
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/attachment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/attachment/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAGrF,OAAO,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAA;AAClF,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAA;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAA;AAGhF,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAGvD,YAAY,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AAC7E,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA"}

package/build/src/services/attachment/index.js

@@ -0,0 +1,15 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+// Main service
+export { default as AttachmentRecordService } from './attachment_recorder_service.js';
+// Specialized services
+export { AttachmentTransactionService } from './attachment_transaction_service.js';
+export { AttachmentPersisterService } from './attachment_persister_service.js';
+export { AttachmentVariantService } from './attachment_variant_service.js';
+export { AttachmentDetachmentService } from './attachment_detachment_service.js';
+// Utilities
+export { AttachmentUtils } from './attachment_utils.js';

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

@@ -0,0 +1,8 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export { AttachmentRecordService as default } from './attachment/index.js';
+//# sourceMappingURL=attachment_service.d.ts.map

package/build/src/services/attachment_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_service.d.ts","sourceRoot":"","sources":["../../../src/services/attachment_service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,uBAAuB,IAAI,OAAO,EAAE,MAAM,uBAAuB,CAAA"}

package/build/src/services/attachment_service.js

@@ -0,0 +1,7 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export { AttachmentRecordService as default } from './attachment/index.js';