@jrmc/adonis-attachment 5.0.0-beta.2 → 5.0.0-beta.4

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;
+    }): 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;IACH,cAAc,CAAC,OAAO,EAAE;QACtB,aAAa,EAAE,MAAM,CAAA;QACrB,gBAAgB,CAAC,EAAE,OAAO,CAAA;QAC1B,aAAa,CAAC,EAAE,OAAO,CAAA;KACxB,GAAG,cAAc,EAAE;CAoBrB"}

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

@@ -0,0 +1,119 @@
+/**
+ * @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
+     */
+    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((attachment) => {
+            if (attachment) {
+                attachment.setOptions(opts).makeFolder(this.#row);
+            }
+        });
+        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;IAQpE;;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,43 @@
+/**
+ * @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((attachment) => 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';

package/build/src/services/variant/variant_generator_service.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { Attachment, Variant, LucidOptions } from '../../types/attachment.js';
+import type { Converter } from '../../types/converter.js';
+export default class VariantGeneratorService {
+    #private;
+    generate({ attachments, options, filters }: {
+        attachments: Attachment[];
+        options: LucidOptions;
+        filters?: {
+            variants?: string[];
+        };
+    }): Promise<Variant[]>;
+    generateVariant({ key, attachment, converter }: {
+        key: string;
+        attachment: Attachment;
+        converter: Converter;
+    }): Promise<Variant | null>;
+}
+//# sourceMappingURL=variant_generator_service.d.ts.map

package/build/src/services/variant/variant_generator_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant_generator_service.d.ts","sourceRoot":"","sources":["../../../../src/services/variant/variant_generator_service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAClF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAOzD,MAAM,CAAC,OAAO,OAAO,uBAAuB;;IACpC,QAAQ,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;QAChD,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,OAAO,EAAE,YAAY,CAAC;QACtB,OAAO,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAA;KAClC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAmBhB,eAAe,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;QACpD,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,UAAU,CAAC;QACvB,SAAS,EAAE,SAAS,CAAA;KACrB,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;CAkF5B"}

package/build/src/services/variant/variant_generator_service.js

@@ -0,0 +1,97 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import logger from '@adonisjs/core/services/logger';
+import attachmentManager from '../../../services/main.js';
+import { streamToTempFile } from '../../utils/helpers.js';
+export default class VariantGeneratorService {
+    async generate({ attachments, options, filters }) {
+        const variants = [];
+        const variantKeys = this.#getVariantKeysToProcess(options, filters);
+        for (const key of variantKeys) {
+            const converter = await this.#getConverter(key);
+            if (!converter)
+                continue;
+            for (const attachment of attachments) {
+                const variant = await this.generateVariant({ key, attachment, converter });
+                if (variant) {
+                    variants.push(variant);
+                }
+            }
+        }
+        return variants;
+    }
+    async generateVariant({ key, attachment, converter }) {
+        try {
+            const input = await this.#prepareInput(attachment);
+            const output = await this.#convertFile(input, converter);
+            if (!output) {
+                // throw new errors.E_CANNOT_PATH_BY_CONVERTER()
+                logger.warn(`Converter returned no output for key: ${key}`);
+                return null;
+            }
+            const variant = await attachment.createVariant(key, output);
+            await this.#processBlurhash(variant, converter);
+            await attachmentManager.write(variant);
+            return variant;
+        }
+        catch (error) {
+            logger.error(`Failed to generate variant ${key} for attachment: ${error.message}`);
+            return null;
+        }
+    }
+    #getVariantKeysToProcess(options, filters) {
+        if (!options.variants)
+            return [];
+        return options.variants.filter(key => filters?.variants === undefined ||
+            filters.variants.includes(key));
+    }
+    async #getConverter(key) {
+        try {
+            return await attachmentManager.getConverter(key);
+        }
+        catch (error) {
+            logger.error(`Failed to get converter for key ${key}: ${error.message}`);
+            return null;
+        }
+    }
+    async #prepareInput(attachment) {
+        if (attachment.input) {
+            return attachment.input;
+        }
+        const stream = await attachment.getStream();
+        return await streamToTempFile(stream);
+    }
+    async #convertFile(input, converter) {
+        if (!converter.handle) {
+            throw new Error('Converter handle method is required');
+        }
+        if (!converter.options) {
+            throw new Error('Converter options are required');
+        }
+        return await converter.handle({
+            input,
+            options: converter.options,
+        });
+    }
+    async #processBlurhash(variant, converter) {
+        const blurhashConfig = converter.options?.blurhash;
+        if (!blurhashConfig)
+            return;
+        const shouldGenerate = typeof blurhashConfig === 'boolean'
+            ? blurhashConfig
+            : blurhashConfig.enabled === true;
+        if (!shouldGenerate)
+            return;
+        try {
+            const options = typeof blurhashConfig !== 'boolean' ? blurhashConfig : undefined;
+            await variant.generateBlurhash(options);
+        }
+        catch (error) {
+            logger.error(`Blurhash generation failed: ${error.message}`);
+        }
+    }
+}