@jrmc/adonis-attachment 2.2.0 → 2.3.1

package/README.md

@@ -8,6 +8,8 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 
 [View documentation](https://adonis-attachment.jrmc.dev/)
 
+[Discord](https://discord.gg/89eMn2vB)
+
 [ChangeLog](https://adonis-attachment.jrmc.dev/changelog.html)
 
 ⚠️ [Breaking change](https://adonis-attachment.jrmc.dev/changelog.html) version 2, include [@adonisjs/drive](https://docs.adonisjs.com/guides/digging-deeper/drive)
@@ -18,44 +20,61 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 - [x] save meta data
 - [x] variantes
   - [x] images
-  - [ ] documents thumbnail
+  - [x] documents thumbnail
   - [x] videos thumbnail
 - [ ] command regenerate
+- [ ] command make:convert
 - [x] adonis-drive/flydrive
 - [ ] jobs queue
 - [x] serialize
 
-### Meta data list (if available)
 
-- extension name
-- size
-- dimension (width, height)
-- created date
-- orientation
-- mime type
-- gps
+## Setup
 
-### Variants
+Install and configure the package:
 
-Configure differents images sizes and formats
+```sh
+node ace add @jrmc/adonis-attachment
+```
 
-### Regenerate (coming soon)
+## Sample
 
-Regenerate variantes files
+Simple upload file
 
-### Drive
+```ts
+// app/models/user.ts
+import { BaseModel } from '@adonisjs/lucid/orm'
+import { compose } from '@adonisjs/core/helpers'
+import { attachment, Attachmentable } from '@jrmc/adonis-attachment'
+import type { Attachment } from '@jrmc/adonis-attachment/types/attachment' // [!code highlight]
 
-Use [@adonisjs/drive](https://docs.adonisjs.com/guides/digging-deeper/drive) for private file and cloud services
+class User extends compose(BaseModel, Attachmentable) { // [!code highlight]
+  @attachment() // [!code highlight]
+  declare avatar: Attachment // [!code highlight]
+}
+```
 
-### Jobs queue (coming soon)
+---
 
-Couple with a job queue (recommended, optional)
+```ts
+// app/controllers/users_controller.ts
+import { attachmentManager } from '@jrmc/adonis-attachment' // [!code focus]
 
-## Setup
+class UsersController {
+  public store({ request }: HttpContext) {
+    const avatar = request.file('avatar')! // [!code focus]
+    const user = new User()
 
-Install and configure the package:
+    user.avatar = await attachmentManager.createFromFile(avatar) // [!code focus]
+    await user.save()
+  }
+}
+```
 
-```sh
-node ace add @jrmc/adonis-attachment
+---
+
+```edge
+<img src="{{ await user.avatar.getUrl() }}" loading="lazy" alt="" />
 ```
 
+Read [documentation](https://adonis-attachment.jrmc.dev/) for advanced usage(thumbnail video/pdf/doc, create from buffer/base64...)

package/build/index.d.ts

@@ -4,4 +4,5 @@ export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
 export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
+export * as errors from './src/errors.js';
 export { attachmentManager };

package/build/index.js

@@ -4,4 +4,5 @@ export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
 export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
+export * as errors from './src/errors.js';
 export { attachmentManager };

package/build/providers/attachment_provider.js

@@ -17,12 +17,11 @@ export default class AttachmentProvider {
             const { AttachmentManager } = await import('../src/attachment_manager.js');
             const attachmentConfig = this.app.config.get('attachment');
             const config = await configProvider.resolve(this.app, attachmentConfig);
-            const logger = await this.app.container.make('logger');
             const drive = await this.app.container.make('drive.manager');
             if (!config) {
                 throw new RuntimeException('Invalid config exported from "config/attachment.ts" file. Make sure to use the defineConfig method');
             }
-            this.#manager = new AttachmentManager(config, logger, drive);
+            this.#manager = new AttachmentManager(config, drive);
             return this.#manager;
         });
     }

package/build/src/adapters/exif.js

@@ -8,7 +8,7 @@ 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, use } from '../utils/helpers.js';
+import { bufferToTempFile, cleanObject, use } from '../utils/helpers.js';
 import { attachmentManager } from '../../index.js';
 export const exif = async (input) => {
     let fileType;
@@ -106,7 +106,11 @@ async function imageExif(buffer) {
 async function videoExif(input) {
     return new Promise(async (resolve) => {
         const ffmpeg = await use('fluent-ffmpeg');
-        const ff = ffmpeg(input);
+        let file = input;
+        if (Buffer.isBuffer(input)) {
+            file = await bufferToTempFile(input);
+        }
+        const ff = ffmpeg(file);
         const config = attachmentManager.getConfig();
         if (config.bin) {
             if (config.bin.ffprobePath) {

package/build/src/attachment_manager.d.ts

@@ -4,7 +4,6 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import type { LoggerService } from '@adonisjs/core/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';
@@ -13,11 +12,12 @@ import { Attachment } from './attachments/attachment.js';
 import Converter from './converters/converter.js';
 export declare class AttachmentManager {
     #private;
-    constructor(config: ResolvedAttachmentConfig, logger: LoggerService, drive: DriveService);
+    constructor(config: ResolvedAttachmentConfig, drive: DriveService);
     getConfig(): ResolvedAttachmentConfig;
     createFromDbResponse(response: any): Attachment | null;
     createFromFile(file: MultipartFile): Promise<Attachment>;
     createFromBuffer(buffer: Buffer, name?: string): Promise<Attachment>;
+    createFromBase64(data: string, name?: string): Promise<Attachment>;
     getConverter(key: string): Promise<void | Converter>;
     computeUrl(attachment: AttachmentType | AttachmentBase, signedUrlOptions?: SignedURLOptions): Promise<void>;
     preComputeUrl(attachment: AttachmentType): Promise<void>;

package/build/src/attachment_manager.js

@@ -4,17 +4,15 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import { Exception } from '@poppinss/utils';
+import * as errors from './errors.js';
 import { Attachment } from './attachments/attachment.js';
-import { createAttachmentAttributes } from './utils/helpers.js';
+import { createAttachmentAttributes, isBase64 } from './utils/helpers.js';
 import { exif } from './adapters/exif.js';
 const REQUIRED_ATTRIBUTES = ['name', 'size', 'extname', 'mimeType'];
 export class AttachmentManager {
-    #logger;
     #config;
     #drive;
-    constructor(config, logger, drive) {
-        this.#logger = logger;
+    constructor(config, drive) {
         this.#drive = drive;
         this.#config = config;
     }
@@ -28,7 +26,7 @@ export class AttachmentManager {
         const attributes = typeof response === 'string' ? JSON.parse(response) : response;
         REQUIRED_ATTRIBUTES.forEach((attribute) => {
             if (attributes[attribute] === undefined) {
-                throw new Exception(`Cannot create attachment from database response. Missing attribute "${attribute}"`);
+                throw new errors.E_CANNOT_CREATE_ATTACHMENT([attribute]);
             }
         });
         return new Attachment(this.#drive, attributes);
@@ -41,14 +39,25 @@ export class AttachmentManager {
             size: file.size,
         };
         if (!file.tmpPath) {
-            throw new Error("It's not a valid file");
+            throw new errors.ENOENT();
         }
         return new Attachment(this.#drive, attributes, file.tmpPath);
     }
     async createFromBuffer(buffer, name) {
+        if (!Buffer.isBuffer(buffer)) {
+            throw new errors.E_ISNOT_BUFFER();
+        }
         const attributes = await createAttachmentAttributes(buffer, name);
         return new Attachment(this.#drive, attributes, buffer);
     }
+    async createFromBase64(data, name) {
+        const base64Data = data.replace(/^data:([A-Za-z-+\/]+);base64,/, '');
+        if (!isBase64(base64Data)) {
+            throw new errors.E_ISNOT_BASE64();
+        }
+        const buffer = Buffer.from(base64Data, 'base64');
+        return await this.createFromBuffer(buffer, name);
+    }
     async getConverter(key) {
         if (this.#config.converters) {
             for (const c of this.#config.converters) {
@@ -89,47 +98,22 @@ export class AttachmentManager {
         else {
             attachment.meta = undefined;
         }
-        try {
-            if (Buffer.isBuffer(attachment.input)) {
-                await attachment.getDisk().put(destinationPath, attachment.input);
-            }
-            else if (attachment.input) {
-                await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
-            }
+        if (Buffer.isBuffer(attachment.input)) {
+            await attachment.getDisk().put(destinationPath, attachment.input);
         }
-        catch (err) {
-            this.#logger.error({ err }, 'Error send file');
+        else if (attachment.input) {
+            await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
         }
     }
     async delete(attachment) {
         if (attachment.path) {
-            try {
-                const filePath = attachment.path;
-                try {
-                    await attachment.getDisk().delete(filePath);
-                }
-                catch (accessError) {
-                    if (accessError.code === 'ENOENT') {
-                        this.#logger.warn(`File not found: ${filePath}`);
-                    }
-                    else {
-                        throw accessError;
-                    }
+            const filePath = attachment.path;
+            await attachment.getDisk().delete(filePath);
+            if (attachment instanceof Attachment) {
+                if (attachment.variants) {
+                    const variantPath = attachment.variants[0].folder;
+                    await attachment.getDisk().deleteAll(variantPath);
                 }
-                if (attachment instanceof Attachment) {
-                    if (attachment.variants) {
-                        const variantPath = attachment.variants[0].folder;
-                        try {
-                            await attachment.getDisk().deleteAll(variantPath);
-                        }
-                        catch (rmError) {
-                            this.#logger.error(`Failed to remove variants folder: ${rmError.message}`);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                this.#logger.error(error);
             }
         }
     }

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

@@ -0,0 +1,13 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
+import Converter from './converter.js';
+export default class DocumentThumbnailConverter extends Converter {
+    handle({ input, options }: ConverterAttributes): Promise<any>;
+    documentToImage(LibreOfficeFileConverter: any, input: Input): Promise<any>;
+}

package/build/src/converters/document_thumbnail_converter.js

@@ -0,0 +1,60 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import logger from '@adonisjs/core/services/logger';
+import Converter from './converter.js';
+import ImageConverter from './image_converter.js';
+import { use } from '../utils/helpers.js';
+export default class DocumentThumbnailConverter extends Converter {
+    async handle({ input, options }) {
+        try {
+            const lib = await use('libreoffice-file-converter');
+            const LibreOfficeFileConverter = lib.LibreOfficeFileConverter;
+            const outputBuffer = await this.documentToImage(LibreOfficeFileConverter, input);
+            if (options && outputBuffer) {
+                const converter = new ImageConverter();
+                return await converter.handle({
+                    input: outputBuffer,
+                    options
+                });
+            }
+            return outputBuffer;
+        }
+        catch (err) {
+            logger.error({ err });
+        }
+    }
+    async documentToImage(LibreOfficeFileConverter, input) {
+        let binaryPaths = undefined;
+        if (this.binPaths && this.binPaths.libreofficePaths) {
+            binaryPaths = this.binPaths.libreofficePaths;
+        }
+        const libreOfficeFileConverter = new LibreOfficeFileConverter({
+            childProcessOptions: {
+                timeout: 60 * 1000,
+            },
+            binaryPaths
+        });
+        if (Buffer.isBuffer(input)) {
+            const output = await libreOfficeFileConverter.convert({
+                buffer: input,
+                input: 'buffer',
+                output: 'buffer',
+                format: 'jpeg',
+            });
+            return output;
+        }
+        else {
+            const output = await libreOfficeFileConverter.convert({
+                inputPath: input,
+                input: 'file',
+                output: 'buffer',
+                format: 'jpeg',
+            });
+            return output;
+        }
+    }
+}

package/build/src/converters/image_converter.js

@@ -4,12 +4,13 @@
  * @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 }) {
-        const sharp = await use('sharp');
-        if (sharp) {
+        try {
+            const sharp = await use('sharp');
             const resize = options?.resize || {};
             let format = options?.format || 'webp';
             let formatoptions = {};
@@ -24,5 +25,8 @@ export default class ImageConverter extends Converter {
                 .toBuffer();
             return buffer;
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
 }

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

@@ -0,0 +1,13 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
+import Converter from './converter.js';
+export default class PdfThumbnailConverter extends Converter {
+    handle({ input, options }: ConverterAttributes): Promise<any>;
+    pdfToImage(Poppler: any, input: Input): Promise<string>;
+}

package/build/src/converters/pdf_thumbnail_converter.js

@@ -0,0 +1,48 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { cuid } from '@adonisjs/core/helpers';
+import logger from '@adonisjs/core/services/logger';
+import Converter from './converter.js';
+import ImageConverter from './image_converter.js';
+import { use } from '../utils/helpers.js';
+export default class PdfThumbnailConverter extends Converter {
+    async handle({ input, options }) {
+        try {
+            const nodePoppler = await use('node-poppler');
+            const Poppler = nodePoppler.Poppler;
+            const filePath = await this.pdfToImage(Poppler, input);
+            if (options && filePath) {
+                const converter = new ImageConverter();
+                return await converter.handle({
+                    input: filePath,
+                    options
+                });
+            }
+            return filePath;
+        }
+        catch (err) {
+            logger.error({ err });
+        }
+    }
+    async pdfToImage(Poppler, input) {
+        let binPath = null;
+        if (this.binPaths && this.binPaths.pdftocairoBasePath) {
+            binPath = this.binPaths.pdftocairoBasePath;
+        }
+        const poppler = new Poppler(binPath);
+        const options = {
+            // firstPageToConvert: 1,
+            lastPageToConvert: 1,
+            jpegFile: true,
+        };
+        const filePath = path.join(os.tmpdir(), cuid());
+        await poppler.pdfToCairo(input, filePath, options);
+        return filePath + '-1.jpg';
+    }
+}

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

@@ -5,8 +5,8 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
 import Converter from './converter.js';
-import { Input } from '../types/input.js';
 export default class VideoThumbnailConvert extends Converter {
     handle({ input, options }: ConverterAttributes): Promise<any>;
     videoToImage(ffmpeg: Function, input: Input): Promise<string | false>;

package/build/src/converters/video_thumbnail_converter.js

@@ -7,13 +7,14 @@
 import os from 'node:os';
 import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
+import logger from '@adonisjs/core/services/logger';
 import Converter from './converter.js';
 import ImageConverter from './image_converter.js';
-import { use } from '../utils/helpers.js';
+import { bufferToTempFile, use } from '../utils/helpers.js';
 export default class VideoThumbnailConvert extends Converter {
     async handle({ input, options }) {
-        const ffmpeg = await use('fluent-ffmpeg');
-        if (ffmpeg) {
+        try {
+            const ffmpeg = await use('fluent-ffmpeg');
             const filePath = await this.videoToImage(ffmpeg, input);
             if (options && filePath) {
                 const converter = new ImageConverter();
@@ -26,12 +27,19 @@ export default class VideoThumbnailConvert extends Converter {
                 return filePath;
             }
         }
+        catch (err) {
+            logger.error({ err });
+        }
     }
     async videoToImage(ffmpeg, input) {
+        let file = input;
+        if (Buffer.isBuffer(input)) {
+            file = await bufferToTempFile(input);
+        }
         return new Promise((resolve) => {
             const folder = os.tmpdir();
             const filename = `${cuid()}.png`;
-            const ff = ffmpeg(input);
+            const ff = ffmpeg(file);
             if (this.binPaths) {
                 if (this.binPaths.ffmpegPath) {
                     ff.setFfmpegPath(this.binPaths.ffmpegPath);

package/build/src/errors.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+/**
+ * Unable to write file to the destination
+ */
+export declare const E_CANNOT_WRITE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to read file
+ */
+export declare const E_CANNOT_READ_FILE: new (args: [key: string], options?: ErrorOptions) => import(
+/**
+ * Unable to read file
+ */
+"@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to delete file
+ */
+export declare const E_CANNOT_DELETE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to set file visibility
+ */
+export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?: ErrorOptions) => import(
+/**
+ * Unable to read file
+ */
+"@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to generate URL for a file
+ */
+export declare const E_CANNOT_GENERATE_URL: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * The file key has unallowed set of characters
+ */
+export declare const E_UNALLOWED_CHARACTERS: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Key post normalization leads to an empty string
+ */
+export declare const E_INVALID_KEY: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Missing package
+ */
+export declare const E_MISSING_PACKAGE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to create Attachment Object
+ */
+export declare const E_CANNOT_CREATE_ATTACHMENT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Is not a Buffer
+ */
+export declare const E_ISNOT_BUFFER: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Is not a Base64
+ */
+export declare const E_ISNOT_BASE64: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Unable to read file
+ */
+export declare const ENOENT: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;

package/build/src/errors.js

@@ -0,0 +1,56 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { createError } from '@adonisjs/core/exceptions';
+import { errors } from 'flydrive';
+/**
+ * Unable to write file to the destination
+ */
+export const E_CANNOT_WRITE_FILE = errors.E_CANNOT_WRITE_FILE;
+/**
+ * Unable to read file
+ */
+export const E_CANNOT_READ_FILE = errors.E_CANNOT_READ_FILE;
+/**
+ * Unable to delete file
+ */
+export const E_CANNOT_DELETE_FILE = errors.E_CANNOT_DELETE_FILE;
+/**
+ * Unable to set file visibility
+ */
+export const E_CANNOT_SET_VISIBILITY = errors.E_CANNOT_SET_VISIBILITY;
+/**
+ * Unable to generate URL for a file
+ */
+export const E_CANNOT_GENERATE_URL = errors.E_CANNOT_GENERATE_URL;
+/**
+ * The file key has unallowed set of characters
+ */
+export const E_UNALLOWED_CHARACTERS = errors.E_UNALLOWED_CHARACTERS;
+/**
+ * Key post normalization leads to an empty string
+ */
+export const E_INVALID_KEY = errors.E_INVALID_KEY;
+/**
+ * Missing package
+ */
+export const E_MISSING_PACKAGE = createError('Missing package, please install "%s"', 'E_MISSING_PACKAGE');
+/**
+ * Unable to create Attachment Object
+ */
+export const E_CANNOT_CREATE_ATTACHMENT = createError('Cannot create attachment from database response. Missing attribute "%s"', 'E_CANNOT_CREATE_ATTACHMENT');
+/**
+ * Is not a Buffer
+ */
+export const E_ISNOT_BUFFER = createError('Is not a Buffer', 'E_ISNOT_BUFFER');
+/**
+ * Is not a Base64
+ */
+export const E_ISNOT_BASE64 = createError('Is not a Base64', 'E_ISNOT_BASE64');
+/**
+ * Unable to read file
+ */
+export const ENOENT = createError('File not found', 'ENOENT');

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

@@ -369,7 +369,6 @@ export declare const Attachmentable: <Model extends NormalizeConstructor<typeof
         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>;
     find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
-    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -416,6 +415,7 @@ export declare const Attachmentable: <Model extends NormalizeConstructor<typeof
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
     };
+    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
     findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
     findBy: {

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

@@ -16,6 +16,8 @@ type ConverterConfig = {
 export type BinPaths = {
     ffmpegPath?: string;
     ffprobePath?: string;
+    pdftocairoBasePath?: string;
+    libreofficePaths?: Array<string>;
 };
 export type AttachmentConfig = {
     bin?: BinPaths;

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

@@ -18,3 +18,5 @@ export declare function createAttachmentAttributes(input: Input, name?: string):
 export declare function cleanObject(obj: any): any;
 export declare function clone(object: Object): any;
 export declare function use(module: string): Promise<any>;
+export declare function bufferToTempFile(input: Buffer): Promise<string>;
+export declare function isBase64(str: string): boolean;

package/build/src/utils/helpers.js

@@ -4,11 +4,14 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'fs/promises';
 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 * as errors from '../errors.js';
 import { optionsSym } from './symbols.js';
 export function getAttachmentAttributeNames(modelInstance) {
     return Object.keys(modelInstance.$attributes).filter((attr) => modelInstance.$attributes[attr] instanceof Attachment);
@@ -61,9 +64,31 @@ export function clone(object) {
 export async function use(module) {
     try {
         const result = await import(module);
-        return result.default;
+        if (result.default) {
+            return result.default;
+        }
+        return result;
+    }
+    catch (err) {
+        throw new errors.E_MISSING_PACKAGE([module], { cause: err });
+    }
+}
+export async function bufferToTempFile(input) {
+    const folder = os.tmpdir();
+    const tempFilePath = path.join(folder, `tempfile-${Date.now()}.tmp`);
+    await fs.writeFile(tempFilePath, input);
+    return tempFilePath;
+}
+export function isBase64(str) {
+    const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+    if (!base64Regex.test(str)) {
+        return false;
+    }
+    try {
+        Buffer.from(str, 'base64').toString();
+        return true;
     }
-    catch (error) {
-        logger.error({ err: error }, `Dependence missing, please install ${module}`);
+    catch (err) {
+        return false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -56,7 +56,6 @@
     "./attachment_provider": "./build/providers/attachment_provider.js"
   },
   "dependencies": {
-    "@poppinss/utils": "^6.7.3",
     "exifreader": "^4.23.3",
     "file-type": "^19.4.0"
   },

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

@@ -1,7 +0,0 @@
-export {};
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */

package/build/src/converters/document_converter.js

@@ -1,7 +0,0 @@
-export {};
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */

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

@@ -1,7 +0,0 @@
-export {};
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */

package/build/src/converters/pdf_converter.js

@@ -1,7 +0,0 @@
-export {};
-/**
- * @jrmc/adonis-attachment
- *
- * @license MIT
- * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
- */