@jrmc/adonis-attachment 2.4.2 → 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/index.d.ts

@@ -6,3 +6,4 @@ export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
 export * as errors from './src/errors.js';
 export { attachmentManager };
+export { type AttachmentVariants } from './src/types/config.js';

package/build/providers/attachment_provider.d.ts

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

package/build/services/main.d.ts

@@ -4,6 +4,6 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import { AttachmentManager } from '../src/attachment_manager.js';
-declare let manager: AttachmentManager;
+import { AttachmentService } from '../src/types/config.js';
+declare let manager: AttachmentService;
 export { manager as default };

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

@@ -7,18 +7,21 @@
 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';
-import type { ResolvedAttachmentConfig } from './types/config.js';
 import { DeferQueue } from '@poppinss/defer';
 import Converter from './converters/converter.js';
-export declare class AttachmentManager {
+import { ResolvedAttachmentConfig } from './define_config.js';
+export declare class AttachmentManager<KnownConverters extends Record<string, Converter>> {
     #private;
     queue: DeferQueue;
-    constructor(config: ResolvedAttachmentConfig, drive: DriveService);
-    getConfig(): ResolvedAttachmentConfig;
+    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>;
+    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,13 +70,21 @@ 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) {
-            for (const c of this.#config.converters) {
-                if (c.key === key) {
-                    return c.converter;
-                }
-            }
+            return this.#config.converters[key];
         }
     }
     async computeUrl(attachment, signedUrlOptions) {
@@ -100,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/define_config.d.ts

@@ -4,6 +4,20 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import type { AttachmentConfig, ResolvedAttachmentConfig } from './types/config.js';
+import type { AttachmentConfig, BinPaths, ConverterConfig, Queue } from './types/config.js';
 import { ConfigProvider } from '@adonisjs/core/types';
-export declare function defineConfig(config: AttachmentConfig): ConfigProvider<ResolvedAttachmentConfig>;
+import { Converter } from './types/converter.js';
+/**
+ * Config resolved by the "defineConfig" method
+ */
+export type ResolvedAttachmentConfig<KnownConverters extends Record<string, Converter>> = {
+    bin?: BinPaths;
+    meta?: boolean;
+    rename?: boolean;
+    preComputeUrl?: boolean;
+    converters?: {
+        [K in keyof KnownConverters]: KnownConverters[K];
+    };
+    queue?: Queue;
+};
+export declare function defineConfig<KnownConverter extends Record<string, ConverterConfig>>(config: AttachmentConfig<KnownConverter>): ConfigProvider<ResolvedAttachmentConfig<KnownConverter>>;

package/build/src/define_config.js

@@ -8,21 +8,20 @@ import { configProvider } from '@adonisjs/core';
 // export function defineConfig<T extends AttachmentConfig>(config: T): T {
 export function defineConfig(config) {
     return configProvider.create(async (_app) => {
-        let convertersMap = [];
+        const convertersList = Object.keys(config.converters || {});
+        const converters = {};
         if (config.converters) {
-            convertersMap = await Promise.all(config.converters.map(async (c) => {
+            for (let converterName of convertersList) {
+                const converter = config.converters[converterName];
                 const binConfig = config.bin;
-                const { default: value } = await c.converter();
+                const { default: value } = await converter.converter();
                 const Converter = value;
-                return {
-                    key: c.key,
-                    converter: new Converter(c.options, binConfig),
-                };
-            }));
+                converters[converterName] = new Converter(converter.options, binConfig);
+            }
         }
         return {
             ...config,
-            converters: convertersMap,
+            converters,
         };
     });
 }

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