@jrmc/adonis-attachment 2.0.2 → 2.1.0

package/build/src/adapters/exif.js

@@ -8,7 +8,8 @@ import fs from 'node:fs/promises';
 import ExifReader from 'exifreader';
 import logger from '@adonisjs/core/services/logger';
 import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
-import { cleanObject } from '../utils/helpers.js';
+import { cleanObject, use } from '../utils/helpers.js';
+import { attachmentManager } from '../../index.js';
 export const exif = async (input) => {
     let fileType;
     let buffer;
@@ -104,10 +105,15 @@ async function imageExif(buffer) {
 }
 async function videoExif(input) {
     return new Promise(async (resolve) => {
-        const module = 'fluent-ffmpeg';
-        const result = await import(module);
-        const ffmpeg = result.default;
-        ffmpeg(input).ffprobe(0, (err, data) => {
+        const ffmpeg = await use('fluent-ffmpeg');
+        const ff = ffmpeg(input);
+        const config = attachmentManager.getConfig();
+        if (config.bin) {
+            if (config.bin.ffprobePath) {
+                ff.setFfprobePath(config.bin.ffprobePath);
+            }
+        }
+        ff.ffprobe(0, (err, data) => {
             if (err) {
                 logger.error({ err });
             }

package/build/src/attachment_manager.d.ts

@@ -14,6 +14,7 @@ import Converter from './converters/converter.js';
 export declare class AttachmentManager {
     #private;
     constructor(config: ResolvedAttachmentConfig, logger: LoggerService, drive: DriveService);
+    getConfig(): ResolvedAttachmentConfig;
     createFromDbResponse(response: any): Attachment | null;
     createFromFile(file: MultipartFile): Promise<Attachment>;
     createFromBuffer(buffer: Buffer, name?: string): Promise<Attachment>;

package/build/src/attachment_manager.js

@@ -7,6 +7,7 @@
 import { Exception } from '@poppinss/utils';
 import { Attachment } from './attachments/attachment.js';
 import { createAttachmentAttributes } from './utils/helpers.js';
+import { exif } from './adapters/exif.js';
 const REQUIRED_ATTRIBUTES = ['name', 'size', 'extname', 'mimeType'];
 export class AttachmentManager {
     #logger;
@@ -17,6 +18,9 @@ export class AttachmentManager {
         this.#drive = drive;
         this.#config = config;
     }
+    getConfig() {
+        return this.#config;
+    }
     createFromDbResponse(response) {
         if (response === null) {
             return null;
@@ -55,8 +59,13 @@ export class AttachmentManager {
         }
     }
     async save(attachment) {
-        await attachment.beforeSave();
         const destinationPath = attachment.path;
+        if (attachment.options?.meta) {
+            attachment.meta = await exif(attachment.input);
+        }
+        else {
+            attachment.meta = undefined;
+        }
         try {
             if (Buffer.isBuffer(attachment.input)) {
                 await attachment.getDisk().put(destinationPath, attachment.input);

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

@@ -5,7 +5,7 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
-import type { AttachmentAttributes, Attachment as AttachmentInterface } from '../types/attachment.js';
+import type { AttachmentAttributes, Attachment as AttachmentInterface, LucidOptions } from '../types/attachment.js';
 import type { Input } from '../types/input.js';
 import { AttachmentBase } from './attachment_base.js';
 import { Variant } from './variant_attachment.js';
@@ -17,7 +17,7 @@ export declare class Attachment extends AttachmentBase implements AttachmentInte
     getVariant(variantName: string): Variant | undefined;
     getUrl(variantName?: string): Promise<string>;
     getSignedUrl(variantNameOrOptions?: string | SignedURLOptions, signedUrlOptions?: SignedURLOptions): Promise<string>;
-    beforeSave(): Promise<void>;
+    setOptions(options: LucidOptions): this;
     toObject(): AttachmentAttributes;
     toJSON(): Promise<Object>;
 }

package/build/src/attachments/attachment.js

@@ -67,14 +67,19 @@ export class Attachment extends AttachmentBase {
         }
         return super.getSignedUrl(options);
     }
-    async beforeSave() {
-        this.folder = this.options.folder;
-        const outputPath = path.join(this.folder, this.name);
-        if (!this.meta) {
-            const data = await createAttachmentAttributes(this.input);
-            this.meta = data.meta;
+    setOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        if (!this.path) {
+            if (!this.options.rename) {
+                this.name = this.originalName;
+            }
+            this.folder = this.options.folder;
+            this.path = path.join(this.folder, this.name);
         }
-        this.path = outputPath;
+        return this;
     }
     toObject() {
         const variants = this.variants?.map((v) => v.toObject());

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

@@ -22,8 +22,7 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
     getDisk(): import("flydrive").Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
-    setOptions(options?: LucidOptions): this;
-    beforeSave(): Promise<void>;
+    setOptions(options: LucidOptions): this;
     toObject(): AttachmentBaseAttributes;
     toJSON(): Promise<Object>;
 }

package/build/src/attachments/attachment_base.js

@@ -50,7 +50,6 @@ export class AttachmentBase {
         };
         return this;
     }
-    async beforeSave() { }
     toObject() {
         return {
             name: this.name,

package/build/src/attachments/variant_attachment.js

@@ -11,7 +11,6 @@ export class Variant extends AttachmentBase {
     folder;
     constructor(drive, attributes, input) {
         super(drive, attributes, input);
-        this.meta = attributes.meta;
         this.key = attributes.key;
         this.folder = attributes.folder;
         this.path = path.join(this.folder, this.name);

package/build/src/converter_manager.js

@@ -26,9 +26,9 @@ export class ConverterManager {
         const attachment = record.$attributes[attribute];
         const data = {};
         const variant = await attachment.createVariant(this.#key, output);
+        await attachmentManager.save(variant);
         data[attribute] = JSON.stringify(attachment.toObject());
         const trx = await db.transaction();
-        trx.after('commit', () => attachmentManager.save(variant));
         trx.after('rollback', () => attachmentManager.delete(variant));
         try {
             await trx.query().from(Model.table).where('id', id).update(data);

package/build/src/converters/autodetect_converter.js

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

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

@@ -4,8 +4,10 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { BinPaths } from '../types/config.js';
 import type { Converter as ConverterInterface, ConverterOptions } from '../types/converter.js';
 export default class Converter implements ConverterInterface {
     options?: ConverterOptions;
-    constructor(options?: ConverterOptions);
+    binPaths?: BinPaths;
+    constructor(options?: ConverterOptions, binPaths?: BinPaths);
 }

package/build/src/converters/converter.js

@@ -6,7 +6,9 @@
  */
 export default class Converter {
     options;
-    constructor(options) {
+    binPaths;
+    constructor(options, binPaths) {
         this.options = options;
+        this.binPaths = binPaths;
     }
 }

package/build/src/converters/image_converter.js

@@ -4,19 +4,11 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
+import { use } from '../utils/helpers.js';
 export default class ImageConverter extends Converter {
     async handle({ input, options }) {
-        let sharp;
-        try {
-            const module = 'sharp';
-            const result = await import(module);
-            sharp = result.default;
-        }
-        catch (error) {
-            logger.error({ err: error }, 'Dependence missing, please install sharp');
-        }
+        const sharp = await use('sharp');
         if (sharp) {
             const resize = options?.resize || {};
             let format = options?.format || 'webp';

package/build/src/converters/video_thumbnail_converter.js

@@ -6,21 +6,13 @@
  */
 import os from 'node:os';
 import path from 'node:path';
-import logger from '@adonisjs/core/services/logger';
 import { cuid } from '@adonisjs/core/helpers';
 import Converter from './converter.js';
 import ImageConverter from './image_converter.js';
+import { use } from '../utils/helpers.js';
 export default class VideoThumbnailConvert extends Converter {
     async handle({ input, options }) {
-        let ffmpeg;
-        try {
-            const module = 'fluent-ffmpeg';
-            const result = await import(module);
-            ffmpeg = result.default;
-        }
-        catch (error) {
-            logger.error({ err: error }, 'Dependence missing, please install fluent-ffmpeg');
-        }
+        const ffmpeg = await use('fluent-ffmpeg');
         if (ffmpeg) {
             const filePath = await this.videoToImage(ffmpeg, input);
             if (options && filePath) {
@@ -39,8 +31,13 @@ export default class VideoThumbnailConvert extends Converter {
         return new Promise((resolve) => {
             const folder = os.tmpdir();
             const filename = `${cuid()}.png`;
-            ffmpeg(input)
-                .screenshots({
+            const ff = ffmpeg(input);
+            if (this.binPaths) {
+                if (this.binPaths.ffmpegPath) {
+                    ff.setFfmpegPath(this.binPaths.ffmpegPath);
+                }
+            }
+            ff.screenshots({
                 count: 1,
                 filename,
                 folder,

package/build/src/decorators/attachment.js

@@ -12,10 +12,21 @@ export const attachment = (options) => {
         if (!target[optionsSym]) {
             target[optionsSym] = {};
         }
+        const defaultConfig = attachmentManager.getConfig();
+        const defaultOptions = {
+            meta: defaultConfig.meta !== undefined ? defaultConfig.meta : defaultOptionsDecorator.meta,
+            rename: defaultConfig.rename !== undefined ? defaultConfig.rename : defaultOptionsDecorator.rename,
+        };
+        if (!options || options?.meta === undefined) {
+            options.meta = defaultOptions.meta;
+        }
+        if (!options || options?.rename === undefined) {
+            options.rename = defaultOptions.rename;
+        }
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
         Model.boot();
-        const { disk, folder, variants, ...columnOptions } = {
+        const { disk, folder, variants, meta, rename, ...columnOptions } = {
             ...defaultOptionsDecorator,
             ...options,
         };
@@ -23,7 +34,7 @@ export const attachment = (options) => {
             consume: (value) => {
                 if (value) {
                     const attachment = attachmentManager.createFromDbResponse(value);
-                    attachment?.setOptions({ disk, folder, variants });
+                    attachment?.setOptions({ disk, folder, variants, meta, rename });
                     return attachment;
                 }
                 else {

package/build/src/define_config.js

@@ -11,15 +11,17 @@ export function defineConfig(config) {
         let convertersMap = [];
         if (config.converters) {
             convertersMap = await Promise.all(config.converters.map(async (c) => {
+                const binConfig = config.bin;
                 const { default: value } = await c.converter();
                 const Converter = value;
                 return {
                     key: c.key,
-                    converter: new Converter(c.options),
+                    converter: new Converter(c.options, binConfig),
                 };
             }));
         }
         return {
+            ...config,
             converters: convertersMap,
         };
     });

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

@@ -22,8 +22,7 @@ export type AttachmentBase = {
     getDisk(): Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
-    setOptions(options?: LucidOptions): AttachmentBase;
-    beforeSave(): Promise<void>;
+    setOptions(options: LucidOptions): AttachmentBase;
     toObject(): AttachmentBaseAttributes;
     toJSON(): Promise<Object>;
 };
@@ -45,6 +44,8 @@ export type LucidOptions = {
     disk?: string;
     folder?: string;
     variants?: string[];
+    rename?: boolean;
+    meta?: boolean;
 };
 export type AttachmentBaseAttributes = {
     name?: string;

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

@@ -13,7 +13,14 @@ type ConverterConfig = {
     converter: () => Promise<ImportConverter>;
     options?: ConverterOptions;
 };
+export type BinPaths = {
+    ffmpegPath?: string;
+    ffprobePath?: string;
+};
 export type AttachmentConfig = {
+    bin?: BinPaths;
+    meta?: boolean;
+    rename?: boolean;
     converters?: ConverterConfig[];
 };
 export type ResolvedConverter = {
@@ -21,6 +28,9 @@ export type ResolvedConverter = {
     converter: Converter;
 };
 export type ResolvedAttachmentConfig = {
+    bin?: BinPaths;
+    meta?: boolean;
+    rename?: boolean;
     converters?: ResolvedConverter[];
 };
 export {};

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

@@ -4,10 +4,12 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { BinPaths } from './config.js';
 import type { Input } from './input.js';
 import type { ModelWithAttachment } from './mixin.js';
 export type Converter = {
     options?: ConverterOptions;
+    binPaths?: BinPaths;
     handle?: (attributes: ConverterAttributes) => Promise<Input | undefined>;
 };
 export type ConverterInitializeAttributes = {

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

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

package/build/src/utils/default_values.js

@@ -8,6 +8,8 @@ export const defaultOptionsDecorator = {
     disk: undefined,
     folder: 'uploads',
     variants: [],
+    rename: true,
+    meta: true
 };
 export const defaultStateAttributeMixin = {
     attached: [],

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

@@ -14,7 +14,7 @@ export declare function createAttachmentAttributes(input: Input, name?: string):
     extname: import("file-type").FileExtension;
     mimeType: import("file-type").MimeType;
     size: number;
-    meta: import("../types/input.js").Exif | undefined;
 }>;
 export declare function cleanObject(obj: any): any;
 export declare function clone(object: Object): any;
+export declare function use(module: string): Promise<any>;

package/build/src/utils/helpers.js

@@ -6,10 +6,10 @@
  */
 import { cuid } from '@adonisjs/core/helpers';
 import string from '@adonisjs/core/helpers/string';
+import logger from '@adonisjs/core/services/logger';
 import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
 import { Attachment } from '../attachments/attachment.js';
 import { optionsSym } from './symbols.js';
-import { exif } from '../adapters/exif.js';
 export function getAttachmentAttributeNames(modelInstance) {
     return Object.keys(modelInstance.$attributes).filter((attr) => modelInstance.$attributes[attr] instanceof Attachment);
 }
@@ -24,7 +24,6 @@ export async function createAttachmentAttributes(input, name) {
     else {
         fileType = await fileTypeFromFile(input);
     }
-    const meta = await exif(input);
     if (name) {
         name = string.slug(name);
     }
@@ -36,7 +35,6 @@ export async function createAttachmentAttributes(input, name) {
         extname: fileType.ext,
         mimeType: fileType.mime,
         size: input.length,
-        meta: meta,
     };
 }
 export function cleanObject(obj) {
@@ -60,3 +58,12 @@ export function cleanObject(obj) {
 export function clone(object) {
     return JSON.parse(JSON.stringify(object));
 }
+export async function use(module) {
+    try {
+        const result = await import(module);
+        return result.default;
+    }
+    catch (error) {
+        logger.error({ err: error }, `Dependence missing, please install ${module}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -77,7 +77,7 @@
   "peerDependencies": {
     "@adonisjs/core": "^6.12.1",
     "@adonisjs/drive": "^3.2.0",
-    "@adonisjs/lucid": "^20.6.0"
+    "@adonisjs/lucid": "^20.6.0 || ^21.0.0"
   },
   "prettier": "@adonisjs/prettier-config",
   "publishConfig": {
@@ -85,6 +85,6 @@
     "tag": "latest"
   },
   "volta": {
-    "node": "20.16.0"
+    "node": "20.17.0"
   }
 }