@jrmc/adonis-attachment 3.0.0 → 3.2.0

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/providers/attachment_provider.d.ts

@@ -5,7 +5,7 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { ApplicationService } from '@adonisjs/core/types';
-import { AttachmentService } from '../src/types/config.js';
+import type { AttachmentService } from '../src/types/config.js';
 declare module '@adonisjs/core/types' {
     interface ContainerBindings {
         'jrmc.attachment': AttachmentService;

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

@@ -5,4 +5,10 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { Exif, Input } from '../types/input.js';
-export declare const exif: (input: Input) => Promise<Exif | undefined>;
+import { ResolvedAttachmentConfig } from '../define_config.js';
+import { Converter } from '../types/converter.js';
+type KnownConverters = Record<string, Converter>;
+declare const _default: {
+    exif(input: Input, config: ResolvedAttachmentConfig<KnownConverters>): Promise<Exif | undefined>;
+};
+export default _default;

package/build/src/adapters/exif.js

@@ -9,8 +9,12 @@ import ExifReader from 'exifreader';
 import logger from '@adonisjs/core/services/logger';
 import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
 import { bufferToTempFile, cleanObject, use } from '../utils/helpers.js';
-import { attachmentManager } from '../../index.js';
-export const exif = async (input) => {
+export default {
+    async exif(input, config) {
+        return exif(input, config);
+    },
+};
+const exif = async (input, config) => {
     let fileType;
     let buffer;
     if (Buffer.isBuffer(input)) {
@@ -26,7 +30,7 @@ export const exif = async (input) => {
         }
     }
     if (fileType?.mime.includes('video')) {
-        return videoExif(input);
+        return videoExif(input, config);
     }
     if (buffer && fileType?.mime.includes('image')) {
         return imageExif(buffer);
@@ -103,7 +107,7 @@ async function imageExif(buffer) {
     }
     return cleanObject(data);
 }
-async function videoExif(input) {
+async function videoExif(input, config) {
     return new Promise(async (resolve) => {
         const ffmpeg = await use('fluent-ffmpeg');
         let file = input;
@@ -111,7 +115,6 @@ async function videoExif(input) {
             file = await bufferToTempFile(input);
         }
         const ff = ffmpeg(file);
-        const config = attachmentManager.getConfig();
         if (config.bin) {
             if (config.bin.ffprobePath) {
                 ff.setFfprobePath(config.bin.ffprobePath);

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,9 +16,12 @@ 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>;
-    createFromBuffer(buffer: Buffer, name?: string): Promise<AttachmentType>;
-    createFromBase64(data: string, 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>;
     preComputeUrl(attachment: AttachmentType): 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, isBase64 } from './utils/helpers.js';
-import { exif } from './adapters/exif.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,34 +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 createFromBuffer(buffer, name) {
-        if (!Buffer.isBuffer(buffer)) {
+    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(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(input, name) {
+        const tmpPath = await downloadToTempFile(input);
+        return this.createFromPath(tmpPath, name || path.basename(input.pathname));
+    }
+    async createFromStream(stream, name) {
+        const tmpPath = await streamToTempFile(stream);
+        return this.createFromPath(tmpPath, name || path.basename(tmpPath));
     }
     async getConverter(key) {
         if (this.#config.converters) {
@@ -96,7 +125,7 @@ export class AttachmentManager {
     async save(attachment) {
         const destinationPath = attachment.path;
         if (attachment.options?.meta) {
-            attachment.meta = await exif(attachment.input);
+            attachment.meta = await ExifAdapter.exif(attachment.input, this.#config);
         }
         else {
             attachment.meta = undefined;

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

@@ -28,6 +28,10 @@ export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?
  * 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;
+/**
+ * Unable to generate temp file
+ */
+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
  */

package/build/src/errors.js

@@ -26,6 +26,10 @@ 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;
+/**
+ * Unable to generate temp file
+ */
+export const E_CANNOT_GENERATE_TEMP_FILE = createError('Cannot generate temp file "%s"', 'E_CANNOT_GENERATE_TEMP_FILE');
 /**
  * The file key has unallowed set of characters
  */