@jrmc/adonis-attachment 3.1.0 → 3.2.1

package/README.md

@@ -17,6 +17,10 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 ## Roadmap
 
 - [x] attachment file by file system
+- [x] attachment file by buffer
+- [x] attachment file by path
+- [x] attachment file by url
+- [x] attachment file by stream
 - [x] save meta data
 - [x] variantes
   - [x] images

package/build/src/adapters/meta.d.ts

@@ -0,0 +1,3 @@
+import { Meta } from '../types/input.js';
+export declare function metaFormBuffer(input: Buffer): Promise<Meta>;
+export declare function metaFormFile(input: string, filename: string): Promise<Meta>;

package/build/src/adapters/meta.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
+import mime from 'mime-types';
+function getFileExtension(filename) {
+    if (!filename) {
+        return '';
+    }
+    const ext = path.extname(filename).slice(1);
+    return ext && /^[a-zA-Z0-9]+$/.test(ext) ? ext : '';
+}
+function metaByFileName(filename) {
+    return {
+        ext: getFileExtension(filename),
+        mime: mime.lookup(filename) || '',
+    };
+}
+export async function metaFormBuffer(input) {
+    const fileType = await fileTypeFromBuffer(input);
+    return {
+        extname: fileType?.ext || '',
+        mimeType: fileType?.mime || '',
+        size: input.length,
+    };
+}
+export async function metaFormFile(input, filename) {
+    let fileType;
+    let size = 0;
+    fileType = metaByFileName(filename);
+    if (fileType.ext === '' || fileType.mime === '') {
+        fileType = await fileTypeFromFile(input);
+    }
+    const stats = await fs.stat(input);
+    size = stats.size;
+    return {
+        extname: fileType?.ext || '',
+        mimeType: fileType?.mime || '',
+        size,
+    };
+}

package/build/src/attachment_manager.d.ts

@@ -16,11 +16,11 @@ export declare class AttachmentManager<KnownConverters extends Record<string, Co
     constructor(config: ResolvedAttachmentConfig<KnownConverters>, drive: DriveService);
     getConfig(): ResolvedAttachmentConfig<KnownConverters>;
     createFromDbResponse(response: any): AttachmentType | null;
-    createFromFile(file: MultipartFile): Promise<AttachmentType>;
-    createFromPath(path: string, name?: string): Promise<AttachmentType>;
-    createFromBuffer(buffer: Buffer, name?: string): Promise<AttachmentType>;
-    createFromBase64(data: string, name?: string): Promise<AttachmentType>;
-    createFromUrl(url: URL, name?: string): Promise<AttachmentType>;
+    createFromFile(input: MultipartFile): Promise<AttachmentType>;
+    createFromPath(input: string, name?: string): Promise<AttachmentType>;
+    createFromBuffer(input: Buffer, name?: string): Promise<AttachmentType>;
+    createFromBase64(input: string, name?: string): Promise<AttachmentType>;
+    createFromUrl(input: URL, name?: string): Promise<AttachmentType>;
     createFromStream(stream: NodeJS.ReadableStream, name?: string): Promise<AttachmentType>;
     getConverter(key: string): Promise<void | Converter>;
     computeUrl(attachment: AttachmentType | AttachmentBase, signedUrlOptions?: SignedURLOptions): Promise<void>;

package/build/src/attachment_manager.js

@@ -4,11 +4,14 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import path from 'node:path';
 import { DeferQueue } from '@poppinss/defer';
 import * as errors from './errors.js';
 import { Attachment } from './attachments/attachment.js';
-import { createAttachmentAttributes, downloadToTempFile, isBase64, streamToTempFile } from './utils/helpers.js';
+import { downloadToTempFile, isBase64, streamToTempFile } from './utils/helpers.js';
 import ExifAdapter from './adapters/exif.js';
+import { metaFormBuffer, metaFormFile } from './adapters/meta.js';
+import { cuid } from '@adonisjs/core/helpers';
 const REQUIRED_ATTRIBUTES = ['name', 'size', 'extname', 'mimeType'];
 export class AttachmentManager {
     queue;
@@ -36,51 +39,60 @@ export class AttachmentManager {
         const attachment = new Attachment(this.#drive, attributes);
         return this.#configureAttachment(attachment);
     }
-    async createFromFile(file) {
+    async createFromFile(input) {
         const attributes = {
-            originalName: file.clientName,
-            extname: file.extname,
-            mimeType: `${file.type}/${file.subtype}`,
-            size: file.size,
+            originalName: input.clientName,
+            extname: input.extname,
+            mimeType: `${input.type}/${input.subtype}`,
+            size: input.size,
         };
-        if (!file.tmpPath) {
+        if (!input.tmpPath) {
             throw new errors.ENOENT();
         }
-        const attachment = new Attachment(this.#drive, attributes, file.tmpPath);
+        const attachment = new Attachment(this.#drive, attributes, input.tmpPath);
         return this.#configureAttachment(attachment);
     }
-    async createFromPath(path, name) {
-        const attributes = await createAttachmentAttributes(path, name);
-        const attachment = new Attachment(this.#drive, attributes, path);
+    async createFromPath(input, name) {
+        const meta = await metaFormFile(input, name || input);
+        if (meta.extname === '') {
+            meta.extname = 'tmp';
+            meta.mimeType = 'application/x-temp';
+        }
+        const attributes = {
+            ...meta,
+            originalName: name?.replace('tmp', meta.extname) || path.basename(input),
+        };
+        const attachment = new Attachment(this.#drive, attributes, input);
         return this.#configureAttachment(attachment);
     }
-    async createFromBuffer(buffer, name) {
-        if (!Buffer.isBuffer(buffer)) {
+    async createFromBuffer(input, name) {
+        if (!Buffer.isBuffer(input)) {
             throw new errors.E_ISNOT_BUFFER();
         }
-        const attributes = await createAttachmentAttributes(buffer, name);
-        const attachment = new Attachment(this.#drive, attributes, buffer);
+        const meta = await metaFormBuffer(input);
+        const ext = meta.extname || 'tmp';
+        const attributes = {
+            ...meta,
+            originalName: name || `${cuid()}.${ext}`,
+        };
+        const attachment = new Attachment(this.#drive, attributes, input);
         return this.#configureAttachment(attachment);
     }
-    async createFromBase64(data, name) {
-        const base64Data = data.replace(/^data:([A-Za-z-+\/]+);base64,/, '');
+    async createFromBase64(input, name) {
+        const base64Data = input.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);
+        return this.createFromBuffer(buffer, name);
     }
-    async createFromUrl(url, name) {
-        const path = await downloadToTempFile(url);
-        const attributes = await createAttachmentAttributes(path, name);
-        const attachment = new Attachment(this.#drive, attributes, path);
-        return this.#configureAttachment(attachment);
+    async createFromUrl(input, name) {
+        const tmpPath = await downloadToTempFile(input);
+        return this.createFromPath(tmpPath, name || path.basename(input.pathname));
     }
     async createFromStream(stream, name) {
-        const path = await streamToTempFile(stream);
-        const attributes = await createAttachmentAttributes(path, name);
-        const attachment = new Attachment(this.#drive, attributes, path);
-        return this.#configureAttachment(attachment);
+        const tmpPath = await streamToTempFile(stream);
+        return this.createFromPath(tmpPath, name || path.basename(tmpPath));
     }
     async getConverter(key) {
         if (this.#config.converters) {
@@ -130,8 +142,17 @@ export class AttachmentManager {
             await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {
                 if (attachment.variants) {
-                    const variantPath = attachment.variants[0].folder;
-                    await attachment.getDisk().deleteAll(variantPath);
+                    if (attachment.options?.disk == 'fs') {
+                        const variantPath = attachment.variants[0].folder;
+                        await attachment.getDisk().deleteAll(variantPath);
+                    }
+                    else {
+                        for (const key in attachment.variants) {
+                            if (Object.prototype.hasOwnProperty.call(attachment.variants, key)) {
+                                await attachment.getDisk().delete(attachment.variants[key].path);
+                            }
+                        }
+                    }
                 }
             }
         }

package/build/src/attachments/attachment.js

@@ -7,7 +7,7 @@
 import path from 'node:path';
 import { AttachmentBase } from './attachment_base.js';
 import { Variant } from './variant_attachment.js';
-import { createAttachmentAttributes } from '../utils/helpers.js';
+import { metaFormBuffer, metaFormFile } from '../adapters/meta.js';
 export class Attachment extends AttachmentBase {
     originalName;
     variants;
@@ -35,8 +35,15 @@ export class Attachment extends AttachmentBase {
      * Methods
      */
     async createVariant(key, input) {
+        let meta;
+        if (Buffer.isBuffer(input)) {
+            meta = await metaFormBuffer(input);
+        }
+        else {
+            meta = await metaFormFile(input, this.name);
+        }
         const attributes = {
-            ...(await createAttachmentAttributes(input)),
+            ...meta,
             key,
             folder: path.join(this.options.folder, 'variants', this.name),
         };

package/build/src/decorators/attachment.js

@@ -7,6 +7,9 @@
 import attachmentManager from '../../services/main.js';
 import { optionsSym } from '../utils/symbols.js';
 import { defaultOptionsDecorator } from '../utils/default_values.js';
+import { afterFindHook, afterFetchHook, beforeSaveHook, afterSaveHook, beforeDeleteHook, } from '../utils/hooks.js';
+import { clone } from '../utils/helpers.js';
+import { defaultStateAttributeMixin } from '../utils/default_values.js';
 export const attachment = (options) => {
     return function (target, attributeName) {
         if (!target[optionsSym]) {
@@ -15,6 +18,28 @@ export const attachment = (options) => {
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
         Model.boot();
+        Model.$attachments = clone(defaultStateAttributeMixin);
+        /**
+         * Registering all hooks only once
+         */
+        if (!Model.$hooks.has('find', afterFindHook)) {
+            Model.after('find', afterFindHook);
+        }
+        if (!Model.$hooks.has('fetch', afterFetchHook)) {
+            Model.after('fetch', afterFetchHook);
+        }
+        if (!Model.$hooks.has('paginate', afterFetchHook)) {
+            Model.after('paginate', afterFetchHook);
+        }
+        if (!Model.$hooks.has('save', beforeSaveHook)) {
+            Model.before('save', beforeSaveHook);
+        }
+        if (!Model.$hooks.has('save', afterSaveHook)) {
+            Model.after('save', afterSaveHook);
+        }
+        if (!Model.$hooks.has('delete', beforeDeleteHook)) {
+            Model.before('delete', beforeDeleteHook);
+        }
         const { disk, folder, variants, meta, rename, ...columnOptions } = {
             ...defaultOptionsDecorator,
             ...options,

package/build/src/errors.d.ts

@@ -7,7 +7,7 @@
 /**
  * Unable to write file to the destination
  */
-export declare const E_CANNOT_WRITE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_WRITE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
  * Unable to read file
  */
@@ -15,56 +15,56 @@ export declare const E_CANNOT_READ_FILE: new (args: [key: string], options?: Err
 /**
  * Unable to read file
  */
-"@poppinss/utils/exception").Exception;
+"@adonisjs/core/exceptions").Exception;
 /**
  * Unable to delete file
  */
-export declare const E_CANNOT_DELETE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?: ErrorOptions) => import("@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("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_GENERATE_URL: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
  * Unable to generate temp file
  */
-export declare const E_CANNOT_GENERATE_TEMP_FILE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_GENERATE_TEMP_FILE: 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("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_CREATE_ATTACHMENT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
  * Unable to create variant
  */
-export declare const E_CANNOT_CREATE_VARIANT: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_CREATE_VARIANT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
  * Missing path
  */
-export declare const E_CANNOT_PATH_BY_CONVERTER: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+export declare const E_CANNOT_PATH_BY_CONVERTER: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
  * Is not a Buffer
  */
-export declare const E_ISNOT_BUFFER: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+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("@poppinss/utils/exception").Exception;
+export declare const ENOENT: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;