@jrmc/adonis-attachment 2.1.0 → 2.2.0

package/build/src/attachment_manager.d.ts

@@ -5,9 +5,9 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { LoggerService } from '@adonisjs/core/types';
-import type { DriveService } from '@adonisjs/drive/types';
+import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { MultipartFile } from '@adonisjs/core/bodyparser';
-import type { AttachmentBase } from './types/attachment.js';
+import type { AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
 import type { ResolvedAttachmentConfig } from './types/config.js';
 import { Attachment } from './attachments/attachment.js';
 import Converter from './converters/converter.js';
@@ -19,6 +19,8 @@ export declare class AttachmentManager {
     createFromFile(file: MultipartFile): Promise<Attachment>;
     createFromBuffer(buffer: Buffer, name?: string): Promise<Attachment>;
     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>;
 }

package/build/src/attachment_manager.js

@@ -58,6 +58,29 @@ export class AttachmentManager {
             }
         }
     }
+    async computeUrl(attachment, signedUrlOptions) {
+        const disk = attachment.getDisk();
+        const fileVisibility = await disk.getVisibility(attachment.path);
+        if (fileVisibility === 'private') {
+            attachment.url = await attachment.getSignedUrl(signedUrlOptions);
+        }
+        else {
+            attachment.url = await attachment.getUrl();
+        }
+    }
+    async preComputeUrl(attachment) {
+        if (attachment.options?.preComputeUrl === false) {
+            return;
+        }
+        await this.computeUrl(attachment);
+        if (attachment instanceof Attachment && attachment.variants) {
+            for (const key in attachment.variants) {
+                if (Object.prototype.hasOwnProperty.call(attachment.variants, key)) {
+                    await this.computeUrl(attachment.variants[key]);
+                }
+            }
+        }
+    }
     async save(attachment) {
         const destinationPath = attachment.path;
         if (attachment.options?.meta) {

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

@@ -19,5 +19,5 @@ export declare class Attachment extends AttachmentBase implements AttachmentInte
     getSignedUrl(variantNameOrOptions?: string | SignedURLOptions, signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
     toObject(): AttachmentAttributes;
-    toJSON(): Promise<Object>;
+    toJSON(): Object;
 }

package/build/src/attachments/attachment.js

@@ -79,6 +79,14 @@ export class Attachment extends AttachmentBase {
             this.folder = this.options.folder;
             this.path = path.join(this.folder, this.name);
         }
+        if (this.variants) {
+            this.variants.forEach((v) => {
+                v.setOptions({
+                    ...this.options,
+                    variants: []
+                });
+            });
+        }
         return this;
     }
     toObject() {
@@ -89,7 +97,7 @@ export class Attachment extends AttachmentBase {
             variants,
         };
     }
-    async toJSON() {
+    toJSON() {
         const data = {
             name: this.name,
             originalName: this.originalName,
@@ -97,16 +105,27 @@ export class Attachment extends AttachmentBase {
             extname: this.extname,
             mimetype: this.mimeType,
             meta: this.meta,
-            url: await this.getUrl(),
-            signedUrl: await this.getSignedUrl(),
         };
         if (this.variants) {
-            await Promise.allSettled(this.variants.map(async (v) => {
+            this.variants.map(async (v) => {
                 data[v.key] = {
-                    url: await this.getUrl(v.key),
-                    signedUrl: await this.getSignedUrl(v.key)
+                    name: v.name,
+                    extname: v.extname,
+                    mimetype: v.mimeType,
+                    meta: v.meta,
+                    size: v.size,
                 };
-            }));
+            });
+        }
+        if (this.url) {
+            data.url = this.url;
+        }
+        if (this.variants) {
+            this.variants.map(async (v) => {
+                if (v.url) {
+                    data[v.key].url = v.url;
+                }
+            });
         }
         return data;
     }

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

@@ -17,6 +17,7 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
     meta?: Exif;
     folder?: string;
     path?: string;
+    url?: string;
     options?: LucidOptions;
     constructor(drive: DriveService, attributes: AttachmentBaseAttributes, input?: Input);
     getDisk(): import("flydrive").Disk;
@@ -24,5 +25,5 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
     toObject(): AttachmentBaseAttributes;
-    toJSON(): Promise<Object>;
+    toJSON(): Object;
 }

package/build/src/attachments/attachment_base.js

@@ -16,6 +16,7 @@ export class AttachmentBase {
     meta;
     folder;
     path;
+    url;
     options;
     constructor(drive, attributes, input) {
         this.input = input;
@@ -60,11 +61,13 @@ export class AttachmentBase {
             path: this.path,
         };
     }
-    async toJSON() {
-        return {
-            ...this.toObject(),
-            url: await this.getUrl(),
-            signedUrl: await this.getSignedUrl(),
-        };
+    toJSON() {
+        if (this.url) {
+            return {
+                ...this.toObject(),
+                url: this.url
+            };
+        }
+        return this.toObject();
     }
 }

package/build/src/decorators/attachment.js

@@ -16,6 +16,7 @@ export const attachment = (options) => {
         const defaultOptions = {
             meta: defaultConfig.meta !== undefined ? defaultConfig.meta : defaultOptionsDecorator.meta,
             rename: defaultConfig.rename !== undefined ? defaultConfig.rename : defaultOptionsDecorator.rename,
+            preComputeUrl: defaultConfig.preComputeUrl !== undefined ? defaultConfig.preComputeUrl : defaultOptionsDecorator.preComputeUrl,
         };
         if (!options || options?.meta === undefined) {
             options.meta = defaultOptions.meta;
@@ -23,6 +24,9 @@ export const attachment = (options) => {
         if (!options || options?.rename === undefined) {
             options.rename = defaultOptions.rename;
         }
+        if (!options || options?.preComputeUrl === undefined) {
+            options.preComputeUrl = defaultOptions.preComputeUrl;
+        }
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
         Model.boot();
@@ -42,7 +46,7 @@ export const attachment = (options) => {
                 }
             },
             prepare: (value) => (value ? JSON.stringify(value.toObject()) : null),
-            serialize: async (value) => (value ? await value.toJSON() : null),
+            serialize: (value) => (value ? value.toJSON() : null),
             ...columnOptions,
         });
     };

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

@@ -68,6 +68,126 @@ export declare const Attachmentable: <Model extends NormalizeConstructor<typeof
         toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
         related<Name_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? any[Name_2]["client"] : never;
     };
+    afterFindHook(modelInstance: {
+        $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): any;
+        useConnection(connection: string): 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): any;
+        merge(value: Partial<{
+            $attachments: AttributeOfModelWithAttachment;
+        }>, allowExtraProperties?: boolean): any;
+        enableForceUpdate(): any;
+        save(): Promise<any>;
+        lockForUpdate<T>(callback: (user: any) => T | Promise<T>): Promise<T>;
+        delete(): Promise<void>;
+        refresh(): Promise<any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
+        loadAggregate: <Self extends 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 any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => 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_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? any[Name_2]["client"] : never;
+    }): Promise<void>;
+    afterFetchHook(modelInstances: {
+        $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): any;
+        useConnection(connection: string): 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): any;
+        merge(value: Partial<{
+            $attachments: AttributeOfModelWithAttachment;
+        }>, allowExtraProperties?: boolean): any;
+        enableForceUpdate(): any;
+        save(): Promise<any>;
+        lockForUpdate<T>(callback: (user: any) => T | Promise<T>): Promise<T>;
+        delete(): Promise<void>;
+        refresh(): Promise<any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
+        loadAggregate: <Self extends 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 any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => 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_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? any[Name_2]["client"] : never;
+    }[]): Promise<void>;
     beforeSaveHook(modelInstance: {
         $attachments: AttributeOfModelWithAttachment;
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;

package/build/src/mixins/attachmentable.js

@@ -10,13 +10,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { beforeSave, afterSave, beforeDelete } from '@adonisjs/lucid/orm';
-import { persistAttachment, commit, rollback, generateVariants } from '../utils/actions.js';
+import { beforeSave, afterSave, beforeDelete, afterFind, afterFetch, afterPaginate } from '@adonisjs/lucid/orm';
+import { persistAttachment, commit, rollback, generateVariants, preComputeUrl } from '../utils/actions.js';
 import { clone, getAttachmentAttributeNames } from '../utils/helpers.js';
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
 export const Attachmentable = (superclass) => {
     class ModelWithAttachment extends superclass {
         $attachments = clone(defaultStateAttributeMixin);
+        static async afterFindHook(modelInstance) {
+            const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
+            await Promise.all(attachmentAttributeNames.map((attributeName) => {
+                return preComputeUrl(modelInstance, attributeName);
+            }));
+        }
+        static async afterFetchHook(modelInstances) {
+            await Promise.all(modelInstances.map((row) => this.afterFindHook(row)));
+        }
         static async beforeSaveHook(modelInstance) {
             const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
             /**
@@ -85,6 +94,13 @@ export const Attachmentable = (superclass) => {
             }
         }
     }
+    __decorate([
+        afterFind()
+    ], ModelWithAttachment, "afterFindHook", null);
+    __decorate([
+        afterFetch(),
+        afterPaginate()
+    ], ModelWithAttachment, "afterFetchHook", null);
     __decorate([
         beforeSave()
     ], ModelWithAttachment, "beforeSaveHook", null);

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

@@ -18,13 +18,14 @@ export type AttachmentBase = {
     meta?: Exif;
     folder?: string;
     path?: string;
+    url?: string;
     options?: LucidOptions;
     getDisk(): Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): AttachmentBase;
     toObject(): AttachmentBaseAttributes;
-    toJSON(): Promise<Object>;
+    toJSON(): Object;
 };
 export type Attachment = AttachmentBase & {
     originalName: string;
@@ -43,6 +44,7 @@ export type Variant = AttachmentBase & {
 export type LucidOptions = {
     disk?: string;
     folder?: string;
+    preComputeUrl?: boolean;
     variants?: string[];
     rename?: boolean;
     meta?: boolean;

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

@@ -21,6 +21,7 @@ export type AttachmentConfig = {
     bin?: BinPaths;
     meta?: boolean;
     rename?: boolean;
+    preComputeUrl?: boolean;
     converters?: ConverterConfig[];
 };
 export type ResolvedConverter = {
@@ -31,6 +32,7 @@ export type ResolvedAttachmentConfig = {
     bin?: BinPaths;
     meta?: boolean;
     rename?: boolean;
+    preComputeUrl?: boolean;
     converters?: ResolvedConverter[];
 };
 export {};

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

@@ -14,9 +14,10 @@ export declare function commit(modelInstance: ModelWithAttachment): Promise<void
  */
 export declare function rollback(modelInstance: ModelWithAttachment): Promise<void>;
 /**
- * Persist attachment for a given attachment property
+ * Persist attachment for a given attachment attributeName
  */
-export declare function persistAttachment(modelInstance: ModelWithAttachment, property: string): Promise<void>;
+export declare function persistAttachment(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;
+export declare function preComputeUrl(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;
 /**
  * Launch converter by variant option
  */

package/build/src/utils/actions.js

@@ -20,14 +20,14 @@ export async function rollback(modelInstance) {
     await Promise.allSettled(modelInstance.$attachments.attached.map((attachment) => attachmentManager.delete(attachment)));
 }
 /**
- * Persist attachment for a given attachment property
+ * Persist attachment for a given attachment attributeName
  */
-export async function persistAttachment(modelInstance, property) {
-    const existingFile = modelInstance.$original[property];
-    const newFile = modelInstance.$attributes[property];
-    const options = getOptions(modelInstance, property);
+export async function persistAttachment(modelInstance, attributeName) {
+    const existingFile = modelInstance.$original[attributeName];
+    const newFile = modelInstance.$attributes[attributeName];
+    const options = getOptions(modelInstance, attributeName);
     /**
-     * Skip when the attachment property hasn't been updated
+     * Skip when the attachment attributeName hasn't been updated
      */
     if (existingFile === newFile) {
         return;
@@ -62,6 +62,12 @@ export async function persistAttachment(modelInstance, property) {
         await attachmentManager.save(newFile);
     }
 }
+export async function preComputeUrl(modelInstance, attributeName) {
+    const attachment = modelInstance.$attributes[attributeName];
+    const options = getOptions(modelInstance, attributeName);
+    attachment.setOptions(options);
+    return attachmentManager.preComputeUrl(attachment);
+}
 /**
  * Launch converter by variant option
  */

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

@@ -7,9 +7,10 @@
 export declare const defaultOptionsDecorator: {
     disk: undefined;
     folder: string;
+    preComputeUrl: boolean;
     variants: never[];
-    rename: boolean;
     meta: boolean;
+    rename: boolean;
 };
 export declare const defaultStateAttributeMixin: {
     attached: never[];

package/build/src/utils/default_values.js

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

package/package.json

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