@jrmc/adonis-attachment 3.0.0 → 3.1.0

package/build/bin/test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/bin/test.js

@@ -0,0 +1,34 @@
+import { assert } from '@japa/assert';
+import { expectTypeOf } from '@japa/expect-type';
+import { processCLIArgs, configure, run } from '@japa/runner';
+import { createApp, initializeDatabase } from '../tests/helpers/app.js';
+import { fileSystem } from '@japa/file-system';
+import app from '@adonisjs/core/services/app';
+import { BASE_URL } from '../tests/helpers/index.js';
+let testApp;
+processCLIArgs(process.argv.slice(2));
+configure({
+    files: ['tests/**/*.spec.ts'],
+    plugins: [assert(), fileSystem({ basePath: BASE_URL }), expectTypeOf()],
+    setup: [
+        async () => {
+            testApp = await createApp();
+            await initializeDatabase(testApp);
+        },
+    ],
+    teardown: [
+        async () => {
+            await app.terminate();
+            await testApp.terminate();
+        },
+    ],
+});
+/*
+|--------------------------------------------------------------------------
+| Run tests
+|--------------------------------------------------------------------------
+|
+| The following "run" method is required to execute all the tests.
+|
+*/
+run();

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

@@ -17,8 +17,11 @@ export declare class AttachmentManager<KnownConverters extends Record<string, Co
     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>;
+    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

@@ -7,8 +7,8 @@
 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 { createAttachmentAttributes, downloadToTempFile, isBase64, streamToTempFile } from './utils/helpers.js';
+import ExifAdapter from './adapters/exif.js';
 const REQUIRED_ATTRIBUTES = ['name', 'size', 'extname', 'mimeType'];
 export class AttachmentManager {
     queue;
@@ -49,6 +49,11 @@ export class AttachmentManager {
         const attachment = new Attachment(this.#drive, attributes, file.tmpPath);
         return this.#configureAttachment(attachment);
     }
+    async createFromPath(path, name) {
+        const attributes = await createAttachmentAttributes(path, name);
+        const attachment = new Attachment(this.#drive, attributes, path);
+        return this.#configureAttachment(attachment);
+    }
     async createFromBuffer(buffer, name) {
         if (!Buffer.isBuffer(buffer)) {
             throw new errors.E_ISNOT_BUFFER();
@@ -65,6 +70,18 @@ export class AttachmentManager {
         const buffer = Buffer.from(base64Data, 'base64');
         return await 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 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);
+    }
     async getConverter(key) {
         if (this.#config.converters) {
             return this.#config.converters[key];
@@ -96,7 +113,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/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("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_WRITE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Unable to read file
  */
@@ -15,52 +15,56 @@ export declare const E_CANNOT_READ_FILE: new (args: [key: string], options?: Err
 /**
  * Unable to read file
  */
-"@adonisjs/core/exceptions").Exception;
+"@poppinss/utils/exception").Exception;
 /**
  * Unable to delete file
  */
-export declare const E_CANNOT_DELETE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_DELETE_FILE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Unable to set file visibility
  */
-export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_SET_VISIBILITY: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").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;
+export declare const E_CANNOT_GENERATE_URL: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").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;
 /**
  * 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;
+export declare const E_UNALLOWED_CHARACTERS: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").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;
+export declare const E_INVALID_KEY: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Missing package
  */
-export declare const E_MISSING_PACKAGE: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_MISSING_PACKAGE: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Unable to create Attachment Object
  */
-export declare const E_CANNOT_CREATE_ATTACHMENT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_CREATE_ATTACHMENT: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Unable to create variant
  */
-export declare const E_CANNOT_CREATE_VARIANT: new (args: [key: string], options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_CREATE_VARIANT: new (args: [key: string], options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Missing path
  */
-export declare const E_CANNOT_PATH_BY_CONVERTER: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_CANNOT_PATH_BY_CONVERTER: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Is not a Buffer
  */
-export declare const E_ISNOT_BUFFER: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_ISNOT_BUFFER: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Is not a Base64
  */
-export declare const E_ISNOT_BASE64: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const E_ISNOT_BASE64: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;
 /**
  * Unable to read file
  */
-export declare const ENOENT: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+export declare const ENOENT: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils/exception").Exception;

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
  */