@jrmc/adonis-attachment 2.1.1-1 → 2.2.0

package/build/src/attachment_manager.d.ts

@@ -5,7 +5,7 @@
  * @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, Attachment as AttachmentType } from './types/attachment.js';
 import type { ResolvedAttachmentConfig } from './types/config.js';
@@ -19,7 +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): Promise<void>;
+    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,27 +58,25 @@ export class AttachmentManager {
             }
         }
     }
-    async computeUrl(attachment) {
-        if (attachment.options?.preComputeUrl === false) {
-            return;
-        }
+    async computeUrl(attachment, signedUrlOptions) {
         const disk = attachment.getDisk();
         const fileVisibility = await disk.getVisibility(attachment.path);
         if (fileVisibility === 'private') {
-            attachment.url = await attachment.getSignedUrl();
+            attachment.url = await attachment.getSignedUrl(signedUrlOptions);
         }
         else {
             attachment.url = await attachment.getUrl();
         }
-        if (attachment.variants) {
+    }
+    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)) {
-                    if (fileVisibility === 'private') {
-                        attachment.variants[key].url = await attachment.getSignedUrl(attachment.variants[key].key);
-                    }
-                    else {
-                        attachment.variants[key].url = await attachment.getUrl(attachment.variants[key].key);
-                    }
+                    await this.computeUrl(attachment.variants[key]);
                 }
             }
         }

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() {
@@ -98,15 +106,26 @@ export class Attachment extends AttachmentBase {
             mimetype: this.mimeType,
             meta: this.meta,
         };
+        if (this.variants) {
+            this.variants.map(async (v) => {
+                data[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) => {
-                    data[v.key] = {
-                        url: v.url,
-                    };
-                });
-            }
+        }
+        if (this.variants) {
+            this.variants.map(async (v) => {
+                if (v.url) {
+                    data[v.key].url = v.url;
+                }
+            });
         }
         return data;
     }

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();

package/build/src/mixins/attachmentable.js

@@ -11,7 +11,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { beforeSave, afterSave, beforeDelete, afterFind, afterFetch, afterPaginate } from '@adonisjs/lucid/orm';
-import { persistAttachment, commit, rollback, generateVariants, computeUrl } from '../utils/actions.js';
+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) => {
@@ -20,7 +20,7 @@ export const Attachmentable = (superclass) => {
         static async afterFindHook(modelInstance) {
             const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
             await Promise.all(attachmentAttributeNames.map((attributeName) => {
-                return computeUrl(modelInstance, attributeName);
+                return preComputeUrl(modelInstance, attributeName);
             }));
         }
         static async afterFetchHook(modelInstances) {

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

@@ -17,7 +17,7 @@ export declare function rollback(modelInstance: ModelWithAttachment): Promise<vo
  * Persist attachment for a given attachment attributeName
  */
 export declare function persistAttachment(modelInstance: ModelWithAttachment, attributeName: string): Promise<void>;
-export declare function computeUrl(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

@@ -62,11 +62,11 @@ export async function persistAttachment(modelInstance, attributeName) {
         await attachmentManager.save(newFile);
     }
 }
-export async function computeUrl(modelInstance, attributeName) {
+export async function preComputeUrl(modelInstance, attributeName) {
     const attachment = modelInstance.$attributes[attributeName];
     const options = getOptions(modelInstance, attributeName);
     attachment.setOptions(options);
-    return attachmentManager.computeUrl(attachment);
+    return attachmentManager.preComputeUrl(attachment);
 }
 /**
  * Launch converter by variant option

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

@@ -9,8 +9,8 @@ export declare const defaultOptionsDecorator: {
     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

@@ -9,8 +9,8 @@ export const defaultOptionsDecorator = {
     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.1-1",
+  "version": "2.2.0",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -82,7 +82,7 @@
   "prettier": "@adonisjs/prettier-config",
   "publishConfig": {
     "access": "public",
-    "tag": "beta"
+    "tag": "latest"
   },
   "volta": {
     "node": "20.17.0"