@jrmc/adonis-attachment 2.4.1 → 3.0.0

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

@@ -7,19 +7,18 @@
 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 { Attachment } from './attachments/attachment.js';
 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;
-    createFromDbResponse(response: any): Attachment | null;
-    createFromFile(file: MultipartFile): Promise<Attachment>;
-    createFromBuffer(buffer: Buffer, name?: string): Promise<Attachment>;
-    createFromBase64(data: string, name?: string): Promise<Attachment>;
+    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>;
     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

@@ -33,7 +33,8 @@ export class AttachmentManager {
                 throw new errors.E_CANNOT_CREATE_ATTACHMENT([attribute]);
             }
         });
-        return new Attachment(this.#drive, attributes);
+        const attachment = new Attachment(this.#drive, attributes);
+        return this.#configureAttachment(attachment);
     }
     async createFromFile(file) {
         const attributes = {
@@ -45,14 +46,16 @@ export class AttachmentManager {
         if (!file.tmpPath) {
             throw new errors.ENOENT();
         }
-        return new Attachment(this.#drive, attributes, file.tmpPath);
+        const attachment = new Attachment(this.#drive, attributes, file.tmpPath);
+        return this.#configureAttachment(attachment);
     }
     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);
+        const attachment = new Attachment(this.#drive, attributes, buffer);
+        return this.#configureAttachment(attachment);
     }
     async createFromBase64(data, name) {
         const base64Data = data.replace(/^data:([A-Za-z-+\/]+);base64,/, '');
@@ -64,11 +67,7 @@ export class AttachmentManager {
     }
     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) {
@@ -111,8 +110,7 @@ export class AttachmentManager {
     }
     async delete(attachment) {
         if (attachment.path) {
-            const filePath = attachment.path;
-            await attachment.getDisk().delete(filePath);
+            await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {
                 if (attachment.variants) {
                     const variantPath = attachment.variants[0].folder;
@@ -120,5 +118,21 @@ export class AttachmentManager {
                 }
             }
         }
+        if (attachment.originalPath) {
+            await attachment.getDisk().delete(attachment.originalPath);
+        }
+    }
+    // private methods
+    #configureAttachment(attachment) {
+        if (this.#config.meta !== undefined) {
+            attachment.setOptions({ meta: this.#config.meta });
+        }
+        if (this.#config.rename !== undefined) {
+            attachment.setOptions({ rename: this.#config.rename });
+        }
+        if (this.#config.preComputeUrl !== undefined) {
+            attachment.setOptions({ preComputeUrl: this.#config.preComputeUrl });
+        }
+        return attachment;
     }
 }

package/build/src/attachments/attachment.d.ts

@@ -13,11 +13,21 @@ export declare class Attachment extends AttachmentBase implements AttachmentInte
     originalName: string;
     variants?: Variant[];
     constructor(drive: DriveService, attributes: AttachmentAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get name(): string;
+    /**
+     * Methods
+     */
     createVariant(key: string, input: Input): Promise<Variant>;
     getVariant(variantName: string): Variant | undefined;
     getUrl(variantName?: string): Promise<string>;
     getSignedUrl(variantNameOrOptions?: string | SignedURLOptions, signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
+    /**
+     *
+     */
     toObject(): AttachmentAttributes;
     toJSON(): Object;
 }

package/build/src/attachments/attachment.js

@@ -22,6 +22,18 @@ export class Attachment extends AttachmentBase {
             });
         }
     }
+    /**
+     * Getters
+     */
+    get name() {
+        if (this.options && this.options.rename === false) {
+            return this.originalName;
+        }
+        return super.name;
+    }
+    /**
+     * Methods
+     */
     async createVariant(key, input) {
         const attributes = {
             ...(await createAttachmentAttributes(input)),
@@ -72,13 +84,6 @@ export class Attachment extends AttachmentBase {
             ...this.options,
             ...options,
         };
-        if (!this.path) {
-            if (!this.options.rename) {
-                this.name = this.originalName;
-            }
-            this.folder = this.options.folder;
-            this.path = path.join(this.folder, this.name);
-        }
         if (this.variants) {
             this.variants.forEach((v) => {
                 v.setOptions({
@@ -89,6 +94,9 @@ export class Attachment extends AttachmentBase {
         }
         return this;
     }
+    /**
+     *
+     */
     toObject() {
         const variants = this.variants?.map((v) => v.toObject());
         return {

package/build/src/attachments/attachment_base.d.ts

@@ -8,22 +8,33 @@ import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { LucidOptions, AttachmentBaseAttributes, AttachmentBase as AttachmentBaseInterface } from '../types/attachment.js';
 import type { Exif, Input } from '../types/input.js';
 export declare class AttachmentBase implements AttachmentBaseInterface {
+    #private;
     drive: DriveService;
     input?: Input;
-    name: string;
     size: number;
     extname: string;
     mimeType: string;
     meta?: Exif;
-    folder?: string;
-    path?: string;
+    originalPath?: string;
     url?: string;
     options?: LucidOptions;
     constructor(drive: DriveService, attributes: AttachmentBaseAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get name(): string;
+    get folder(): string | undefined;
+    get path(): string;
+    /**
+     * Methods
+     */
     getDisk(): import("flydrive").Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
+    /**
+     *
+     */
     toObject(): AttachmentBaseAttributes;
     toJSON(): Object;
 }

package/build/src/attachments/attachment_base.js

@@ -4,18 +4,19 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
 import { defaultOptionsDecorator } from '../utils/default_values.js';
 export class AttachmentBase {
     drive;
     input;
-    name;
+    #name;
+    #folder;
     size;
     extname;
     mimeType;
     meta;
-    folder;
-    path;
+    originalPath;
     url;
     options;
     constructor(drive, attributes, input) {
@@ -24,17 +25,35 @@ export class AttachmentBase {
         this.meta = attributes.meta;
         this.extname = attributes.extname;
         this.mimeType = attributes.mimeType;
-        this.folder = attributes.folder;
-        this.path = attributes.path;
-        this.options = defaultOptionsDecorator;
-        this.drive = drive;
+        this.originalPath = attributes.path;
+        this.#folder = attributes.folder;
         if (attributes.name) {
-            this.name = attributes.name;
+            this.#name = attributes.name;
         }
         else {
-            this.name = `${cuid()}.${this.extname}`;
+            this.#name = `${cuid()}.${this.extname}`;
+        }
+        this.options = defaultOptionsDecorator;
+        this.drive = drive;
+    }
+    /**
+     * Getters
+     */
+    get name() {
+        return this.#name;
+    }
+    get folder() {
+        if (this.options) {
+            return this.options?.folder;
         }
+        return this.#folder;
+    }
+    get path() {
+        return path.join(this.folder, this.name);
     }
+    /**
+     * Methods
+     */
     getDisk() {
         return this.drive.use(this.options?.disk);
     }
@@ -51,6 +70,9 @@ export class AttachmentBase {
         };
         return this;
     }
+    /**
+     *
+     */
     toObject() {
         return {
             name: this.name,

package/build/src/attachments/variant_attachment.d.ts

@@ -9,8 +9,15 @@ import type { VariantAttributes, Variant as VariantInterface } from '../types/at
 import type { Input } from '../types/input.js';
 import { AttachmentBase } from './attachment_base.js';
 export declare class Variant extends AttachmentBase implements VariantInterface {
+    #private;
     key: string;
-    folder: string;
     constructor(drive: DriveService, attributes: VariantAttributes, input?: Input);
+    /**
+     * Getters
+     */
+    get folder(): string;
+    /**
+     *
+     */
     toObject(): VariantAttributes;
 }

package/build/src/attachments/variant_attachment.js

@@ -4,17 +4,24 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import path from 'node:path';
 import { AttachmentBase } from './attachment_base.js';
 export class Variant extends AttachmentBase {
     key;
-    folder;
+    #folder;
     constructor(drive, attributes, input) {
         super(drive, attributes, input);
         this.key = attributes.key;
-        this.folder = attributes.folder;
-        this.path = path.join(this.folder, this.name);
+        this.#folder = attributes.folder;
     }
+    /**
+     * Getters
+     */
+    get folder() {
+        return this.#folder;
+    }
+    /**
+     *
+     */
     toObject() {
         return {
             key: this.key,

package/build/src/decorators/attachment.js

@@ -12,23 +12,6 @@ export const attachment = (options) => {
         if (!target[optionsSym]) {
             target[optionsSym] = {};
         }
-        const defaultConfig = attachmentManager.getConfig();
-        const defaultOptions = {
-            meta: defaultConfig.meta !== undefined ? defaultConfig.meta : defaultOptionsDecorator.meta,
-            rename: defaultConfig.rename !== undefined ? defaultConfig.rename : defaultOptionsDecorator.rename,
-            preComputeUrl: defaultConfig.preComputeUrl !== undefined
-                ? defaultConfig.preComputeUrl
-                : defaultOptionsDecorator.preComputeUrl,
-        };
-        if (!options || options?.meta === undefined) {
-            options.meta = defaultOptions.meta;
-        }
-        if (!options || options?.rename === undefined) {
-            options.rename = defaultOptions.rename;
-        }
-        if (!options || options?.preComputeUrl === undefined) {
-            options.preComputeUrl = defaultOptions.preComputeUrl;
-        }
         target[optionsSym][attributeName] = options;
         const Model = target.constructor;
         Model.boot();
@@ -40,7 +23,16 @@ export const attachment = (options) => {
             consume: (value) => {
                 if (value) {
                     const attachment = attachmentManager.createFromDbResponse(value);
-                    attachment?.setOptions({ disk, folder, variants, meta, rename });
+                    attachment?.setOptions({ disk, folder, variants });
+                    if (options && options?.meta !== undefined) {
+                        attachment?.setOptions({ meta: options.meta });
+                    }
+                    if (options && options?.rename !== undefined) {
+                        attachment?.setOptions({ rename: options.rename });
+                    }
+                    if (options && options?.preComputeUrl !== undefined) {
+                        attachment?.setOptions({ preComputeUrl: options.preComputeUrl });
+                    }
                     return attachment;
                 }
                 else {

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

@@ -8,16 +8,18 @@ import type { DriveService } from '@adonisjs/drive/types';
 import type { Exif, Input } from './input.js';
 import type { Disk } from '@adonisjs/drive';
 import type { SignedURLOptions } from '@adonisjs/drive/types';
+import type { AttachmentVariants } from '@jrmc/adonis-attachment';
 export type AttachmentBase = {
     drive: DriveService;
     input?: Input;
     name: string;
+    folder?: string;
+    path?: string;
     size: number;
     extname: string;
     mimeType: string;
     meta?: Exif;
-    folder?: string;
-    path?: string;
+    originalPath?: string;
     url?: string;
     options?: LucidOptions;
     getDisk(): Disk;
@@ -45,7 +47,7 @@ export type LucidOptions = {
     disk?: string;
     folder?: string;
     preComputeUrl?: boolean;
-    variants?: string[];
+    variants?: (keyof AttachmentVariants)[];
     rename?: boolean;
     meta?: boolean;
 };

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

@@ -4,42 +4,45 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import { ConfigProvider } from '@adonisjs/core/types';
 import type { Converter, ConverterOptions } from './converter.js';
+import { AttachmentManager } from '../attachment_manager.js';
 type ImportConverter = {
     default: unknown;
 };
-type ConverterConfig = {
-    key: string;
+export interface ConverterConfig {
     converter: () => Promise<ImportConverter>;
     options?: ConverterOptions;
-};
-type Queue = {
+}
+export interface Queue {
     concurrency: number;
-};
+}
 export type BinPaths = {
     ffmpegPath?: string;
     ffprobePath?: string;
     pdftocairoBasePath?: string;
     libreofficePaths?: Array<string>;
 };
-export type AttachmentConfig = {
-    bin?: BinPaths;
-    meta?: boolean;
-    rename?: boolean;
-    preComputeUrl?: boolean;
-    converters?: ConverterConfig[];
-    queue?: Queue;
-};
-export type ResolvedConverter = {
-    key: string;
-    converter: Converter;
-};
-export type ResolvedAttachmentConfig = {
+export type AttachmentConfig<KnownConverter extends Record<string, ConverterConfig>> = {
     bin?: BinPaths;
     meta?: boolean;
     rename?: boolean;
     preComputeUrl?: boolean;
-    converters?: ResolvedConverter[];
+    converters?: {
+        [K in keyof KnownConverter]: KnownConverter[K];
+    };
     queue?: Queue;
 };
+export interface AttachmentVariants {
+}
+export type InferConverters<Config extends ConfigProvider<{
+    bin?: unknown;
+    meta?: unknown;
+    rename?: unknown;
+    preComputeUrl?: unknown;
+    converters?: unknown;
+    queue?: unknown;
+}>> = Exclude<Awaited<ReturnType<Config['resolver']>>['converters'], undefined>;
+export interface AttachmentService extends AttachmentManager<AttachmentVariants extends Record<string, Converter> ? AttachmentVariants : never> {
+}
 export {};

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

@@ -0,0 +1,5 @@
+export * from './attachment.js';
+export * from './config.js';
+export * from './converter.js';
+export * from './input.js';
+export * from './mixin.js';

package/build/src/types/index.js

@@ -0,0 +1,5 @@
+export * from './attachment.js';
+export * from './config.js';
+export * from './converter.js';
+export * from './input.js';
+export * from './mixin.js';

package/build/stubs/config.stub

@@ -2,15 +2,21 @@
   exports({ to: app.configPath('attachment.ts') })
 }}}
 import { defineConfig } from '@jrmc/adonis-attachment'
+import { InferConverters } from '@jrmc/adonis-attachment/types/config'
 
-export default defineConfig({
-  converters: [
-    {
-      key: 'thumbnail',
+const attachmentConfig = defineConfig({
+  converters: {
+    thumbnail: {
       converter: () => import('@jrmc/adonis-attachment/converters/image_converter'),
       options: {
         resize: 300,
       }
     }
-  ]
+  }
 })
+
+export default attachmentConfig
+
+declare module '@jrmc/adonis-attachment' {
+  interface AttachmentVariants extends InferConverters<typeof attachmentConfig> {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "2.4.1",
+  "version": "3.0.0",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {