@jrmc/adonis-attachment 3.3.0-beta.3 → 3.3.0-beta.5

package/README.md

@@ -2,8 +2,6 @@
 
 This package is currently development and will replace [attachment-advanced](https://github.com/batosai/attachment-advanced) for AdonisJS 6.
 
-Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-kit)
-
 ## Links
 
 [View documentation](https://adonis-attachment.jrmc.dev/)
@@ -12,7 +10,7 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 
 [Discord](https://discord.gg/89eMn2vB)
 
-⚠️ [Breaking change](https://adonis-attachment.jrmc.dev/changelog.html) version 2, include [@adonisjs/drive](https://docs.adonisjs.com/guides/digging-deeper/drive)
+Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-kit)
 
 ## Roadmap
 
@@ -21,9 +19,11 @@ Project sample : [adonis-starter-kit](https://github.com/batosai/adonis-starter-
 - [x] attachment file by path
 - [x] attachment file by url
 - [x] attachment file by stream
+- [x] attachment files
 - [x] save meta data
 - [x] variantes
   - [x] images
+    - [x] [blurhash](https://blurha.sh/)
   - [x] documents thumbnail
   - [x] videos thumbnail
 - [ ] command regenerate

package/build/index.d.ts

@@ -1,4 +1,5 @@
 import attachmentManager from './services/main.js';
+import RegenerateService from './services/regenerate_service.js';
 export { configure } from './configure.js';
 export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
@@ -7,4 +8,5 @@ export { defineConfig } from './src/define_config.js';
 export { Attachmentable } from './src/mixins/attachmentable.js';
 export * as errors from './src/errors.js';
 export { attachmentManager };
+export { RegenerateService };
 export { type AttachmentVariants } from './src/types/config.js';

package/build/index.js

@@ -1,4 +1,5 @@
 import attachmentManager from './services/main.js';
+import RegenerateService from './services/regenerate_service.js';
 export { configure } from './configure.js';
 export { Attachment } from './src/attachments/attachment.js';
 export { attachment } from './src/decorators/attachment.js';
@@ -7,3 +8,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 { RegenerateService };

package/build/services/regenerate_service.d.ts

@@ -0,0 +1,8 @@
+import type { LucidRow, LucidModel } from '@adonisjs/lucid/types/model';
+import type { RegenerateOptions } from '../src/types/regenerate.js';
+export default class RegenerateService {
+    #private;
+    model(Model: LucidModel, options?: RegenerateOptions): this;
+    row(row: LucidRow, options?: RegenerateOptions): this;
+    run(): Promise<void | void[]>;
+}

package/build/services/regenerate_service.js

@@ -0,0 +1,29 @@
+import Record from '../src/services/record_with_attachment.js';
+export default class RegenerateService {
+    #Model;
+    #row;
+    #options;
+    model(Model, options = {}) {
+        this.#Model = Model;
+        this.#options = options;
+        return this;
+    }
+    row(row, options = {}) {
+        this.#row = row;
+        this.#options = options;
+        return this;
+    }
+    async run() {
+        if (this.#row) {
+            const record = new Record(this.#row);
+            return record.regenerateVariants(this.#options);
+        }
+        else if (this.#Model) {
+            const entities = await this.#Model.all();
+            return Promise.all(entities.map(async (entity) => {
+                const record = new Record(entity);
+                return record.regenerateVariants(this.#options);
+            }));
+        }
+    }
+}

package/build/src/attachment_manager.d.ts

@@ -7,14 +7,13 @@
 import type { DriveService, SignedURLOptions } from '@adonisjs/drive/types';
 import type { MultipartFile } from '@adonisjs/core/bodyparser';
 import type { AttachmentAttributes, AttachmentBase, Attachment as AttachmentType } from './types/attachment.js';
+import type { ResolvedAttachmentConfig } from './define_config.js';
 import { DeferQueue } from '@poppinss/defer';
 import Converter from './converters/converter.js';
-import { ResolvedAttachmentConfig } from './define_config.js';
 export declare class AttachmentManager<KnownConverters extends Record<string, Converter>> {
     #private;
     queue: DeferQueue;
     constructor(config: ResolvedAttachmentConfig<KnownConverters>, drive: DriveService);
-    getConfig(): ResolvedAttachmentConfig<KnownConverters>;
     createFromDbResponse(response?: string | JSON): AttachmentType | null;
     createFromFile(input: MultipartFile): Promise<AttachmentType>;
     createFromFiles(inputs: MultipartFile[]): Promise<(AttachmentBase & {
@@ -34,6 +33,6 @@ export declare class AttachmentManager<KnownConverters extends Record<string, Co
     getConverter(key: string): Promise<void | Converter>;
     computeUrl(attachment: AttachmentType | AttachmentBase, signedUrlOptions?: SignedURLOptions): Promise<void>;
     preComputeUrl(attachment: AttachmentType): Promise<void>;
-    save(attachment: AttachmentBase): Promise<void>;
-    delete(attachment: AttachmentBase): Promise<void>;
+    write(attachment: AttachmentBase): Promise<void>;
+    remove(attachment: AttachmentBase): Promise<void>;
 }

package/build/src/attachment_manager.js

@@ -23,9 +23,6 @@ export class AttachmentManager {
         const concurrency = this.#config.queue?.concurrency || 1;
         this.queue = new DeferQueue({ concurrency });
     }
-    getConfig() {
-        return this.#config;
-    }
     createFromDbResponse(response) {
         if (response === null) {
             return null;
@@ -125,7 +122,7 @@ export class AttachmentManager {
             }
         }
     }
-    async save(attachment) {
+    async write(attachment) {
         const destinationPath = attachment.path;
         if (attachment.options?.meta) {
             attachment.meta = await ExifAdapter.exif(attachment.input, this.#config);
@@ -140,7 +137,7 @@ export class AttachmentManager {
             await attachment.getDisk().copyFromFs(attachment.input, destinationPath);
         }
     }
-    async delete(attachment) {
+    async remove(attachment) {
         if (attachment.path) {
             await attachment.getDisk().delete(attachment.path);
             if (attachment instanceof Attachment) {

package/build/src/attachments/attachment.js

@@ -45,7 +45,7 @@ export class Attachment extends AttachmentBase {
         const attributes = {
             ...meta,
             key,
-            folder: path.join(this.options.folder, 'variants', this.name),
+            folder: path.join(this.folder, 'variants', this.name),
         };
         const variant = new Variant(this.drive, attributes, input);
         variant.setOptions(this.options);
@@ -58,17 +58,20 @@ export class Attachment extends AttachmentBase {
     getVariant(variantName) {
         return this.variants?.find((v) => v.key === variantName);
     }
-    getUrl(variantName) {
+    async getUrl(variantName) {
         if (variantName) {
             const variant = this.getVariant(variantName);
             if (variant) {
                 variant.setOptions(this.options);
-                return variant.getUrl();
+                const url = await variant.getUrl();
+                if (url) {
+                    return url;
+                }
             }
         }
         return super.getUrl();
     }
-    getSignedUrl(variantNameOrOptions, signedUrlOptions) {
+    async getSignedUrl(variantNameOrOptions, signedUrlOptions) {
         let variantName;
         let options = signedUrlOptions;
         if (typeof variantNameOrOptions === 'string') {
@@ -81,7 +84,10 @@ export class Attachment extends AttachmentBase {
             const variant = this.getVariant(variantName);
             if (variant) {
                 variant.setOptions(this.options);
-                return variant.getSignedUrl(options);
+                const url = variant.getSignedUrl(options);
+                if (url) {
+                    return url;
+                }
             }
         }
         return super.getSignedUrl(options);

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

@@ -4,6 +4,7 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { LucidRow } from '@adonisjs/lucid/types/model';
 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';
@@ -17,7 +18,7 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
     meta?: Exif;
     originalPath?: string;
     url?: string;
-    options?: LucidOptions;
+    options: LucidOptions;
     constructor(drive: DriveService, attributes: AttachmentBaseAttributes, input?: Input);
     /**
      * Getters
@@ -29,9 +30,11 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
      * Methods
      */
     getDisk(): import("flydrive").Disk;
+    getStream(): Promise<import("stream").Readable>;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): this;
+    makeFolder(record?: LucidRow): this;
     /**
      *
      */

package/build/src/attachments/attachment_base.js

@@ -4,9 +4,11 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import string from '@adonisjs/core/helpers/string';
 import path from 'node:path';
 import { cuid } from '@adonisjs/core/helpers';
 import { defaultOptionsDecorator } from '../utils/default_values.js';
+import { extractPathParameters } from '../utils/helpers.js';
 export class AttachmentBase {
     drive;
     input;
@@ -27,6 +29,7 @@ export class AttachmentBase {
         this.mimeType = attributes.mimeType;
         this.originalPath = attributes.path;
         this.#folder = attributes.folder;
+        this.setOptions({ folder: attributes.folder });
         if (attributes.name) {
             this.#name = attributes.name;
         }
@@ -43,12 +46,20 @@ export class AttachmentBase {
         return this.#name;
     }
     get folder() {
-        if (this.options) {
-            return this.options?.folder;
+        if (this.#folder) {
+            return this.#folder;
+        }
+        if (typeof this.options.folder === 'string') {
+            const parameters = extractPathParameters(this.options.folder);
+            if (!parameters.length) {
+                return this.options.folder;
+            }
         }
-        return this.#folder;
     }
     get path() {
+        if (!this.folder && this.originalPath) {
+            return this.originalPath;
+        }
         return path.join(this.folder, this.name);
     }
     /**
@@ -57,6 +68,9 @@ export class AttachmentBase {
     getDisk() {
         return this.drive.use(this.options?.disk);
     }
+    getStream() {
+        return this.getDisk().getStream(this.path);
+    }
     getUrl() {
         return this.getDisk().getUrl(this.path);
     }
@@ -70,6 +84,27 @@ export class AttachmentBase {
         };
         return this;
     }
+    makeFolder(record) {
+        if (typeof this.options.folder === 'function' && record) {
+            this.#folder = this.options.folder(record);
+        }
+        else if (this.options.folder) {
+            this.#folder = this.options.folder;
+        }
+        if (this.#folder && record) {
+            const parameters = extractPathParameters(this.#folder);
+            if (parameters) {
+                parameters.forEach((parameter) => {
+                    const attribute = record.$attributes[parameter];
+                    if (typeof attribute === 'string') {
+                        const name = string.slug(string.noCase(string.escapeHTML(attribute.toLowerCase())));
+                        this.#folder = this.#folder?.replace(`:${parameter}`, name);
+                    }
+                });
+            }
+        }
+        return this;
+    }
     /**
      *
      */

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

@@ -8,11 +8,13 @@ import type { DriveService } from '@adonisjs/drive/types';
 import type { VariantAttributes, Variant as VariantInterface } from '../types/attachment.js';
 import type { Input } from '../types/input.js';
 import { AttachmentBase } from './attachment_base.js';
+import { BlurhashOptions } from '../types/converter.js';
 export declare class Variant extends AttachmentBase implements VariantInterface {
     #private;
     key: string;
     blurhash?: string;
     constructor(drive: DriveService, attributes: VariantAttributes, input?: Input);
+    generateBlurhash(options?: BlurhashOptions): Promise<void>;
     /**
      * Getters
      */

package/build/src/attachments/variant_attachment.js

@@ -5,6 +5,7 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import { AttachmentBase } from './attachment_base.js';
+import { imageToBlurhash } from '../utils/helpers.js';
 export class Variant extends AttachmentBase {
     key;
     #folder;
@@ -15,6 +16,9 @@ export class Variant extends AttachmentBase {
         this.#folder = attributes.folder;
         this.blurhash = attributes.blurhash;
     }
+    async generateBlurhash(options) {
+        this.blurhash = await imageToBlurhash(this.input, options);
+    }
     /**
      * Getters
      */

package/build/src/converter_manager.d.ts

@@ -1,6 +1,6 @@
 import type { ConverterInitializeAttributes } from './types/converter.js';
 export declare class ConverterManager {
     #private;
-    constructor({ record, attributeName, options }: ConverterInitializeAttributes);
-    save(): Promise<void>;
+    constructor({ record, attributeName, options, filters }: ConverterInitializeAttributes);
+    run(): Promise<void>;
 }

package/build/src/converter_manager.js

@@ -3,71 +3,93 @@ import string from '@adonisjs/core/helpers/string';
 import db from '@adonisjs/lucid/services/db';
 import attachmentManager from '../services/main.js';
 import * as errors from './errors.js';
-import { imageToBlurhash } from './utils/helpers.js';
+import { streamToTempFile } from './utils/helpers.js';
 export class ConverterManager {
     #record;
     #attributeName;
     #options;
-    constructor({ record, attributeName, options }) {
+    #filters;
+    constructor({ record, attributeName, options, filters }) {
         this.#record = record;
         this.#attributeName = attributeName;
         this.#options = options;
+        this.#filters = filters;
     }
-    async save() {
-        let attachments = this.#record.getAttachments({
+    async run() {
+        const attachments = this.#record.getAttachments({
             attributeName: this.#attributeName,
         });
-        const Model = this.#record.model.constructor;
-        const id = this.#record.model.$attributes['id'];
-        const data = {};
-        if (this.#options.variants) {
-            for await (const option of this.#options.variants) {
-                const converter = (await attachmentManager.getConverter(option));
-                if (attachments && converter) {
-                    for await (const attachment of attachments) {
-                        const input = attachment.input;
-                        const output = await converter.handle({
-                            input,
-                            options: converter.options,
-                        });
-                        if (output === undefined) {
-                            throw new errors.E_CANNOT_PATH_BY_CONVERTER();
-                        }
-                        const variant = await attachment.createVariant(option, output);
-                        if (converter.options.blurhash) {
-                            if ((typeof converter.options.blurhash !== 'boolean' &&
-                                converter.options.blurhash.enabled === true) ||
-                                converter.options.blurhash === true) {
-                                try {
-                                    const options = typeof converter.options.blurhash !== 'boolean'
-                                        ? converter.options.blurhash
-                                        : undefined;
-                                    variant.blurhash = await imageToBlurhash(variant.input, options);
-                                }
-                                catch (error) {
-                                    logger.error(error.message);
-                                }
-                            }
-                        }
-                        await attachmentManager.save(variant);
-                    }
+        const variants = [];
+        await this.#purge(attachments);
+        if (!attachments || !this.#options.variants || !this.#options.variants.length) {
+            return;
+        }
+        for await (const key of this.#options.variants) {
+            if (this.#filters?.variants !== undefined && !this.#filters?.variants?.includes(key)) {
+                continue;
+            }
+            const converter = (await attachmentManager.getConverter(key));
+            if (converter) {
+                for await (const attachment of attachments) {
+                    const variant = await this.#generate({
+                        key,
+                        attachment,
+                        converter
+                    });
+                    variants.push(variant);
                 }
             }
         }
-        if (Array.isArray(this.#record.model.$original[this.#attributeName])) {
-            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments.map((att) => att.toObject()));
+        return this.#commit(attachments, () => {
+            for (let i = 0; i < variants.length; i++) {
+                attachmentManager.remove(variants[i]);
+            }
+        });
+    }
+    async #generate({ key, attachment, converter }) {
+        let input = attachment.input;
+        if (!input) {
+            input = await streamToTempFile(await attachment.getStream());
         }
-        else {
-            data[string.snakeCase(this.#attributeName)] = JSON.stringify(attachments[0].toObject());
+        const output = await converter.handle({
+            input,
+            options: converter.options,
+        });
+        if (output === undefined) {
+            throw new errors.E_CANNOT_PATH_BY_CONVERTER();
         }
-        const trx = await db.transaction();
-        trx.after('rollback', () => {
-            for (let i = 0; i < attachments.length; i++) {
-                for (const variant of attachments[i].variants) {
-                    attachmentManager.delete(variant);
+        const variant = await attachment.createVariant(key, output);
+        if (converter.options.blurhash) {
+            if ((typeof converter.options.blurhash !== 'boolean' &&
+                converter.options.blurhash.enabled === true) ||
+                converter.options.blurhash === true) {
+                try {
+                    const options = typeof converter.options.blurhash !== 'boolean'
+                        ? converter.options.blurhash
+                        : undefined;
+                    await variant.generateBlurhash(options);
+                }
+                catch (error) {
+                    logger.error(error.message);
                 }
             }
-        });
+        }
+        await attachmentManager.write(variant);
+        return variant;
+    }
+    async #commit(attachments, rollback) {
+        const Model = this.#record.row.constructor;
+        const id = this.#record.row.$attributes['id'];
+        const data = {};
+        const index = string.snakeCase(this.#attributeName);
+        if (Array.isArray(this.#record.row.$original[this.#attributeName])) {
+            data[index] = JSON.stringify(attachments.map((att) => att.toObject()));
+        }
+        else {
+            data[index] = JSON.stringify(attachments[0].toObject());
+        }
+        const trx = await db.transaction();
+        trx.after('rollback', rollback);
         try {
             await trx.query().from(Model.table).where('id', id).update(data);
             return trx.commit();
@@ -76,4 +98,22 @@ export class ConverterManager {
             return trx.rollback();
         }
     }
+    async #purge(attachments) {
+        return Promise.all(attachments.map(async (attachment) => {
+            if (attachment.variants) {
+                await Promise.all(attachment.variants.map(async (variant) => {
+                    if (this.#filters?.variants !== undefined && !this.#filters?.variants?.includes(variant.key)) {
+                        return;
+                    }
+                    return attachmentManager.remove(variant);
+                }));
+                if (this.#filters?.variants !== undefined) {
+                    attachment.variants = await attachment.variants.filter((variant) => !this.#filters?.variants?.includes(variant.key));
+                }
+                else {
+                    attachment.variants = [];
+                }
+            }
+        }));
+    }
 }

package/build/src/converters/autodetect_converter.d.ts

@@ -5,7 +5,8 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
 import Converter from './converter.js';
 export default class AutodetectConverter extends Converter {
-    handle({ input, options }: ConverterAttributes): Promise<false | import("../types/input.js").Input | undefined>;
+    handle({ input, options }: ConverterAttributes): Promise<Input | undefined>;
 }

package/build/src/converters/autodetect_converter.js

@@ -18,17 +18,15 @@ export default class AutodetectConverter extends Converter {
         else {
             fileType = await fileTypeFromFile(input);
         }
-        if (fileType?.mime.includes('image')) {
-            converter = new ImageConverter(options, this.binPaths);
-        }
-        else if (fileType?.mime.includes('video')) {
+        if (fileType?.mime.includes('video')) {
             converter = new VideoThumnailConverter(options, this.binPaths);
         }
-        if (converter) {
-            return await converter.handle({
-                input,
-                options,
-            });
+        else {
+            converter = new ImageConverter(options, this.binPaths);
         }
+        return converter.handle({
+            input,
+            options,
+        });
     }
 }

package/build/src/converters/converter.d.ts

@@ -5,9 +5,11 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { BinPaths } from '../types/config.js';
-import type { Converter as ConverterInterface, ConverterOptions } from '../types/converter.js';
+import type { Converter as ConverterInterface, ConverterOptions, ConverterAttributes } from '../types/converter.js';
+import type { Input } from '../types/input.js';
 export default class Converter implements ConverterInterface {
     options?: ConverterOptions;
     binPaths?: BinPaths;
     constructor(options?: ConverterOptions, binPaths?: BinPaths);
+    handle({ input }: ConverterAttributes): Promise<Input | undefined>;
 }

package/build/src/converters/converter.js

@@ -11,4 +11,7 @@ export default class Converter {
         this.options = options;
         this.binPaths = binPaths;
     }
+    async handle({ input }) {
+        return input;
+    }
 }

package/build/src/converters/video_thumbnail_converter.d.ts

@@ -8,6 +8,6 @@ import type { ConverterAttributes } from '../types/converter.js';
 import type { Input } from '../types/input.js';
 import Converter from './converter.js';
 export default class VideoThumbnailConvert extends Converter {
-    handle({ input, options }: ConverterAttributes): Promise<false | Input>;
-    videoToImage(ffmpeg: Function, input: Input): Promise<string | false>;
+    handle({ input, options }: ConverterAttributes): Promise<Input | undefined>;
+    videoToImage(ffmpeg: Function, input: Input): Promise<string | undefined>;
 }

package/build/src/converters/video_thumbnail_converter.js

@@ -16,7 +16,7 @@ export default class VideoThumbnailConvert extends Converter {
         const filePath = await this.videoToImage(ffmpeg, input);
         if (options && filePath) {
             const converter = new ImageConverter();
-            return await converter.handle({
+            return converter.handle({
                 input: filePath,
                 options,
             });

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

@@ -6,9 +6,9 @@
  */
 import type { LucidModel } from '@adonisjs/lucid/types/model';
 import type { LucidOptions } from '../types/attachment.js';
-import type { AttributeOfModelWithAttachment } from '../types/mixin.js';
+import type { AttributeOfRowWithAttachment } from '../types/mixin.js';
 export declare const bootModel: (model: LucidModel & {
-    $attachments: AttributeOfModelWithAttachment;
+    $attachments: AttributeOfRowWithAttachment;
 }) => void;
 export declare const attachment: (options?: LucidOptions) => (target: any, attributeName: string) => void;
 export declare const attachments: (options?: LucidOptions) => (target: any, attributeName: string) => void;

package/build/src/define_config.d.ts

@@ -16,8 +16,8 @@ export type ResolvedAttachmentConfig<KnownConverters extends Record<string, Conv
     rename?: boolean;
     preComputeUrl?: boolean;
     converters?: {
-        [K in keyof KnownConverters]: KnownConverters[K];
+        [K in keyof KnownConverters]: Converter;
     };
     queue?: Queue;
 };
-export declare function defineConfig<KnownConverter extends Record<string, ConverterConfig>>(config: AttachmentConfig<KnownConverter>): ConfigProvider<ResolvedAttachmentConfig<KnownConverter>>;
+export declare function defineConfig<KnownConverter extends Record<string, ConverterConfig>>(config: AttachmentConfig<KnownConverter>): ConfigProvider<ResolvedAttachmentConfig<Record<string, Converter>>>;

package/build/src/define_config.js

@@ -5,7 +5,6 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import { configProvider } from '@adonisjs/core';
-// export function defineConfig<T extends AttachmentConfig>(config: T): T {
 export function defineConfig(config) {
     return configProvider.create(async (_app) => {
         const convertersList = Object.keys(config.converters || {});
@@ -14,9 +13,14 @@ export function defineConfig(config) {
             for (let converterName of convertersList) {
                 const converter = config.converters[converterName];
                 const binConfig = config.bin;
-                const { default: value } = await converter.converter();
-                const Converter = value;
-                converters[converterName] = new Converter(converter.options, binConfig);
+                try {
+                    const { default: value } = await converter.converter();
+                    const Converter = value;
+                    converters[converterName] = new Converter(converter.options, binConfig);
+                }
+                catch (error) {
+                    console.error(`Failed to load converter ${converterName}:`, error);
+                }
             }
         }
         return {

package/build/src/mixins/attachmentable.d.ts

@@ -6,11 +6,11 @@
  */
 import type { BaseModel } from '@adonisjs/lucid/orm';
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import type { AttributeOfModelWithAttachment } from '../types/mixin.js';
+import type { AttributeOfRowWithAttachment } from '../types/mixin.js';
 type Constructor = NormalizeConstructor<typeof BaseModel>;
 export declare function Attachmentable<T extends Constructor>(superclass: T): {
     new (...args: any[]): {
-        $attachments: AttributeOfModelWithAttachment;
+        $attachments: AttributeOfRowWithAttachment;
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;
         $extras: import("@adonisjs/lucid/types/model").ModelObject;
         $original: import("@adonisjs/lucid/types/model").ModelObject;
@@ -43,10 +43,10 @@ export declare function Attachmentable<T extends Constructor>(superclass: T): {
         $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
         $hydrateOriginals(): void;
         fill(value: Partial<{
-            $attachments: AttributeOfModelWithAttachment;
+            $attachments: AttributeOfRowWithAttachment;
         }>, allowExtraProperties?: boolean): /*elided*/ any;
         merge(value: Partial<{
-            $attachments: AttributeOfModelWithAttachment;
+            $attachments: AttributeOfRowWithAttachment;
         }>, allowExtraProperties?: boolean): /*elided*/ any;
         isDirty(fields?: "$attachments" | ("$attachments" | undefined)[] | undefined): boolean;
         enableForceUpdate(): /*elided*/ any;

package/build/src/mixins/attachmentable.js

@@ -14,7 +14,7 @@ import { beforeSave, beforeFind, beforeFetch, beforePaginate, beforeCreate, } fr
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
 import logger from '@adonisjs/core/services/logger';
 export function Attachmentable(superclass) {
-    class ModelWithAttachment extends superclass {
+    class RowWithAttachment extends superclass {
         $attachments = structuredClone(defaultStateAttributeMixin);
         static async warn() {
             logger.warn(`The "Attachmentable" mixin is deprecated and may be removed in a future version.`);
@@ -26,6 +26,6 @@ export function Attachmentable(superclass) {
         beforeFetch(),
         beforePaginate(),
         beforeSave()
-    ], ModelWithAttachment, "warn", null);
-    return ModelWithAttachment;
+    ], RowWithAttachment, "warn", null);
+    return RowWithAttachment;
 }

package/build/src/services/record_with_attachment.d.ts

@@ -1,9 +1,10 @@
-import type { ModelWithAttachment } from '../types/mixin.js';
+import type { RowWithAttachment } from '../types/mixin.js';
 import type { Attachment as AttachmentType } from '../types/attachment.js';
 import type { Record as RecordImplementation } from '../types/service.js';
+import type { RegenerateOptions } from '../types/regenerate.js';
 export default class Record implements RecordImplementation {
     #private;
-    constructor(model: ModelWithAttachment);
+    constructor(row: RowWithAttachment);
     /**
      * During commit, we should cleanup the old detached files
      */
@@ -18,11 +19,13 @@ export default class Record implements RecordImplementation {
     }): Promise<void>;
     preComputeUrl(): Promise<void>;
     generateVariants(): Promise<void>;
+    regenerateVariants(options?: RegenerateOptions): Promise<void>;
     detach(): Promise<PromiseSettledResult<void>[]>;
     detachAll(): Promise<PromiseSettledResult<void>[]>;
-    get model(): ModelWithAttachment;
+    get row(): RowWithAttachment;
     getAttachments(options: {
         attributeName: string;
         requiredOriginal?: boolean;
+        requiredDirty?: boolean;
     }): AttachmentType[];
 }

package/build/src/services/record_with_attachment.js

@@ -5,32 +5,32 @@ import { optionsSym } from '../utils/symbols.js';
 import { ConverterManager } from '../converter_manager.js';
 import { E_CANNOT_CREATE_VARIANT } from '../errors.js';
 export default class Record {
-    #model;
-    constructor(model) {
-        this.#model = model;
-        if (!this.#model.$attachments) {
+    #row;
+    constructor(row) {
+        this.#row = row;
+        if (!this.#row.$attachments) {
             /**
              * Empty previous $attachments
              */
-            this.#model.$attachments = structuredClone(defaultStateAttributeMixin);
+            this.#row.$attachments = structuredClone(defaultStateAttributeMixin);
         }
     }
     /**
      * During commit, we should cleanup the old detached files
      */
     async commit() {
-        await Promise.allSettled(this.#model.$attachments.detached.map((attachment) => attachmentManager.delete(attachment)));
+        await Promise.allSettled(this.#row.$attachments.detached.map((attachment) => attachmentManager.remove(attachment)));
     }
     /**
      * During rollback we should remove the attached files.
      */
     async rollback() {
-        await Promise.allSettled(this.#model.$attachments.attached.map((attachment) => attachmentManager.delete(attachment)));
+        await Promise.allSettled(this.#row.$attachments.attached.map((attachment) => attachmentManager.remove(attachment)));
     }
     async persist() {
         const attachmentAttributeNames = this.#getDirtyAttributeNamesOfAttachment();
         /**
-         * Persist attachments before saving the model to the database. This
+         * Persist attachments before saving the row to the database. This
          * way if file saving fails we will not write anything to the
          * database
          */
@@ -47,7 +47,7 @@ export default class Record {
             /**
              * memorise attribute name for generate variants
              */
-            this.#model.$attachments.dirtied.push(name);
+            this.#row.$attachments.dirtied.push(name);
             for (let i = 0; i < newAttachments.length; i++) {
                 if (originalAttachments.includes(newAttachments[i])) {
                     continue;
@@ -57,22 +57,22 @@ export default class Record {
                  * file.
                  */
                 if (newAttachments[i]) {
-                    newAttachments[i].setOptions(options);
-                    this.#model.$attachments.attached.push(newAttachments[i]);
+                    newAttachments[i].setOptions(options).makeFolder(this.#row);
+                    this.#row.$attachments.attached.push(newAttachments[i]);
                     /**
                      * Also write the file to the disk right away
                      */
-                    await attachmentManager.save(newAttachments[i]);
+                    await attachmentManager.write(newAttachments[i]);
                 }
             }
         }));
     }
     async transaction(options = { enabledRollback: true }) {
         try {
-            if (this.#model.$trx) {
-                this.#model.$trx.after('commit', () => this.commit());
+            if (this.#row.$trx) {
+                this.#row.$trx.after('commit', () => this.commit());
                 if (options.enabledRollback) {
-                    this.#model.$trx.after('rollback', () => this.rollback());
+                    this.#row.$trx.after('rollback', () => this.rollback());
                 }
             }
             else {
@@ -90,7 +90,7 @@ export default class Record {
         const attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
         await Promise.all(attachmentAttributeNames.map(async (name) => {
             const options = this.#getOptionsByAttributeName(name);
-            if (this.#model.$attributes[name]) {
+            if (this.#row.$attributes[name]) {
                 const attachments = this.#getAttachmentsByAttributeName(name);
                 for (let i = 0; i < attachments.length; i++) {
                     attachments[i].setOptions(options);
@@ -100,8 +100,8 @@ export default class Record {
         }));
     }
     async generateVariants() {
-        /* this.#model.$dirty is not avalable in afterSave hooks */
-        const attachmentAttributeNames = this.#model.$attachments.dirtied;
+        /* this.#row.$dirty is not avalable in afterSave hooks */
+        const attachmentAttributeNames = this.#row.$attachments.dirtied;
         /**
          * For all properties Attachment
          * Launch async generation variants
@@ -109,7 +109,7 @@ export default class Record {
         for await (const name of attachmentAttributeNames) {
             const record = this;
             attachmentManager.queue.push({
-                name: `${this.#model.constructor.name}-${name}`,
+                name: `${this.#row.constructor.name}-${name}`,
                 async run() {
                     try {
                         const converterManager = new ConverterManager({
@@ -117,7 +117,38 @@ export default class Record {
                             attributeName: name,
                             options: record.#getOptionsByAttributeName(name),
                         });
-                        await converterManager.save();
+                        await converterManager.run();
+                    }
+                    catch (err) {
+                        throw new E_CANNOT_CREATE_VARIANT([err.message]);
+                    }
+                },
+            });
+        }
+    }
+    async regenerateVariants(options = {}) {
+        let attachmentAttributeNames;
+        if (options.attributes?.length) {
+            attachmentAttributeNames = options.attributes;
+        }
+        else {
+            attachmentAttributeNames = this.#getAttributeNamesOfAttachment();
+        }
+        for await (const name of attachmentAttributeNames) {
+            const record = this;
+            attachmentManager.queue.push({
+                name: `${this.#row.constructor.name}-${name}`,
+                async run() {
+                    try {
+                        const converterManager = new ConverterManager({
+                            record,
+                            attributeName: name,
+                            options: record.#getOptionsByAttributeName(name),
+                            filters: {
+                                variants: options.variants
+                            }
+                        });
+                        await converterManager.run();
                     }
                     catch (err) {
                         throw new E_CANNOT_CREATE_VARIANT([err.message]);
@@ -134,7 +165,7 @@ export default class Record {
         return Promise.allSettled(attachmentAttributeNames.map((name) => {
             let attachments = [];
             const options = this.#getOptionsByAttributeName(name);
-            if (this.#model.$dirty[name] === null) {
+            if (this.#row.$dirty[name] === null) {
                 attachments = this.#getOriginalAttachmentsByAttributeName(name);
             }
             else {
@@ -158,7 +189,7 @@ export default class Record {
             }
             for (let i = 0; i < attachments.length; i++) {
                 attachments[i].setOptions(options);
-                this.#model.$attachments.detached.push(attachments[i]);
+                this.#row.$attachments.detached.push(attachments[i]);
             }
         }));
     }
@@ -172,53 +203,68 @@ export default class Record {
             const attachments = this.#getAttachmentsByAttributeName(name);
             for (let i = 0; i < attachments.length; i++) {
                 attachments[i].setOptions(options);
-                this.#model.$attachments.detached.push(attachments[i]);
+                this.#row.$attachments.detached.push(attachments[i]);
             }
         }));
     }
-    get model() {
-        return this.#model;
+    get row() {
+        return this.#row;
     }
     getAttachments(options) {
+        let attachments;
         if (options.requiredOriginal) {
-            return this.#getOriginalAttachmentsByAttributeName(options.attributeName);
+            attachments = this.#getOriginalAttachmentsByAttributeName(options.attributeName);
+        }
+        else if (options.requiredDirty) {
+            attachments = this.#getDirtyAttachmentsByAttributeName(options.attributeName);
         }
         else {
-            return this.#getAttachmentsByAttributeName(options.attributeName);
+            attachments = this.#getAttachmentsByAttributeName(options.attributeName);
         }
+        const opts = this.#getOptionsByAttributeName(options.attributeName);
+        attachments.map((attachment) => attachment.setOptions(opts).makeFolder(this.#row));
+        return attachments;
     }
     #getAttachmentsByAttributeName(name) {
-        if (Array.isArray(this.#model.$attributes[name])) {
-            return this.#model.$attributes[name];
+        if (Array.isArray(this.#row.$attributes[name])) {
+            return this.#row.$attributes[name];
         }
-        return [this.#model.$attributes[name]];
+        return [this.#row.$attributes[name]];
     }
     #getOriginalAttachmentsByAttributeName(name) {
-        if (Array.isArray(this.#model.$original[name])) {
-            return this.#model.$original[name];
+        if (Array.isArray(this.#row.$original[name])) {
+            return this.#row.$original[name];
+        }
+        return [this.#row.$original[name]];
+    }
+    #getDirtyAttachmentsByAttributeName(name) {
+        if (Array.isArray(this.#row.$dirty[name])) {
+            return this.#row.$dirty[name];
         }
-        return [this.#model.$original[name]];
+        return [this.#row.$dirty[name]];
     }
     #getOptionsByAttributeName(name) {
-        return this.#model.constructor.prototype[optionsSym]?.[name];
+        return this.#row.constructor.prototype[optionsSym]?.[name];
     }
     #getAttributeNamesOfAttachment() {
-        return Object.keys(this.#model.$attributes).filter((name) => {
-            const value = this.#model.$attributes[name];
+        return Object.keys(this.#row.$attributes).filter((name) => {
+            const value = this.#row.$attributes[name];
             return (value instanceof Attachment ||
                 (Array.isArray(value) && value.every((item) => item instanceof Attachment)));
         });
     }
     #getDirtyAttributeNamesOfAttachment() {
-        return Object.keys(this.#model.$dirty).filter((name) => {
-            const dirtyValue = this.#model.$dirty[name];
-            const originalValue = this.#model.$original[name]; // if dirtyValue is null, check original type
+        return Object.keys(this.#row.$dirty).filter((name) => {
+            const dirtyValue = this.#row.$dirty[name];
+            const originalValue = this.#row.$original[name]; // if dirtyValue is null, check original type
             const isDirtyAttachment = dirtyValue instanceof Attachment ||
                 (Array.isArray(dirtyValue) &&
-                    dirtyValue.every((item) => item instanceof Attachment) &&
-                    dirtyValue.length);
+                    dirtyValue.length &&
+                    dirtyValue.every((item) => item instanceof Attachment));
             const isOriginalAttachment = originalValue instanceof Attachment ||
-                (Array.isArray(originalValue) && originalValue.every((item) => item instanceof Attachment));
+                (Array.isArray(originalValue) &&
+                    originalValue.length &&
+                    originalValue.every((item) => item instanceof Attachment));
             return isDirtyAttachment || isOriginalAttachment;
         });
     }

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

@@ -4,11 +4,13 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
+import type { LucidRow } from '@adonisjs/lucid/types/model';
 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';
+import { BlurhashOptions } from './converter.js';
 export type AttachmentBase = {
     drive: DriveService;
     input?: Input;
@@ -21,8 +23,10 @@ export type AttachmentBase = {
     meta?: Exif;
     originalPath?: string;
     url?: string;
-    options?: LucidOptions;
+    options: LucidOptions;
+    makeFolder(record?: LucidRow): void;
     getDisk(): Disk;
+    getStream(): Promise<NodeJS.ReadableStream>;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
     setOptions(options: LucidOptions): AttachmentBase;
@@ -42,11 +46,12 @@ export type Variant = AttachmentBase & {
     key: string;
     folder: string;
     blurhash?: string;
+    generateBlurhash(options?: BlurhashOptions): void;
     toObject(): VariantAttributes;
 };
 export type LucidOptions = {
     disk?: string;
-    folder?: string;
+    folder?: string | ((record?: LucidRow) => string);
     preComputeUrl?: boolean;
     variants?: (keyof AttachmentVariants)[];
     rename?: boolean;

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

@@ -4,8 +4,8 @@
  * @license MIT
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
-import { ConfigProvider } from '@adonisjs/core/types';
 import type { Converter, ConverterOptions } from './converter.js';
+import { ConfigProvider } from '@adonisjs/core/types';
 import { AttachmentManager } from '../attachment_manager.js';
 type ImportConverter = {
     default: unknown;

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

@@ -11,12 +11,15 @@ import type { LucidOptions } from './attachment.js';
 export type Converter = {
     options?: ConverterOptions;
     binPaths?: BinPaths;
-    handle?: (attributes: ConverterAttributes) => Promise<Input | undefined>;
+    handle: (attributes: ConverterAttributes) => Promise<Input | undefined>;
 };
 export type ConverterInitializeAttributes = {
     record: Record;
     attributeName: string;
     options: LucidOptions;
+    filters?: {
+        variants?: string[];
+    };
 };
 export type ConverterAttributes = {
     input: Input;
@@ -31,40 +34,40 @@ type jpeg = {
     format: 'jpeg';
     options: {
         quality?: number;
-        progressive?: Boolean;
+        progressive?: boolean;
         chromaSubsampling?: string;
-        optimiseCoding?: Boolean;
-        optimizeCoding?: Boolean;
-        mozjpeg?: Boolean;
-        trellisQuantisation?: Boolean;
-        overshootDeringing?: Boolean;
-        optimiseScans?: Boolean;
-        optimizeScans?: Boolean;
+        optimiseCoding?: boolean;
+        optimizeCoding?: boolean;
+        mozjpeg?: boolean;
+        trellisQuantisation?: boolean;
+        overshootDeringing?: boolean;
+        optimiseScans?: boolean;
+        optimizeScans?: boolean;
         quantisationTable?: number;
         quantizationTable?: number;
-        force?: Boolean;
+        force?: boolean;
     };
 };
 type png = {
     format: 'png';
     options: {
         quality?: number;
-        progressive?: Boolean;
+        progressive?: boolean;
         compressionLevel?: number;
-        adaptiveFiltering?: Boolean;
-        palette?: Boolean;
+        adaptiveFiltering?: boolean;
+        palette?: boolean;
         effort?: number;
         colours?: number;
         colors?: number;
         dither?: number;
-        force?: Boolean;
+        force?: boolean;
     };
 };
 type gif = {
     format: 'gif';
     options: {
-        reuse?: Boolean;
-        progressive?: Boolean;
+        reuse?: boolean;
+        progressive?: boolean;
         colours?: number;
         colors?: number;
         effort?: number;
@@ -73,7 +76,7 @@ type gif = {
         interPaletteMaxError?: number;
         loop?: number;
         delay?: number | number[];
-        force?: Boolean;
+        force?: boolean;
     };
 };
 type webp = {
@@ -81,23 +84,23 @@ type webp = {
     options: {
         quality?: number;
         alphaQuality?: number;
-        lossless?: Boolean;
-        nearLossless?: Boolean;
-        smartSubsample?: Boolean;
+        lossless?: boolean;
+        nearLossless?: boolean;
+        smartSubsample?: boolean;
         preset?: string;
         effort?: number;
         loop?: number;
         delay?: number | number[];
-        minSize?: Boolean;
-        mixed?: Boolean;
-        force?: Boolean;
+        minSize?: boolean;
+        mixed?: boolean;
+        force?: boolean;
     };
 };
 type avif = {
     format: 'avif';
     options: {
         quality?: number;
-        lossless?: Boolean;
+        lossless?: boolean;
         effort?: number;
         chromaSubsampling?: string;
         bitdepth?: number;
@@ -108,7 +111,7 @@ type heif = {
     options: {
         compression?: string;
         quality?: number;
-        lossless?: Boolean;
+        lossless?: boolean;
         effort?: number;
         chromaSubsampling?: string;
         bitdepth?: number;
@@ -127,9 +130,9 @@ export type ConverterOptions = {
             alpha: number;
         };
         kernel?: string;
-        withoutEnlargement?: Boolean;
-        withoutReduction?: Boolean;
-        fastShrinkOnLoad?: Boolean;
+        withoutEnlargement?: boolean;
+        withoutReduction?: boolean;
+        fastShrinkOnLoad?: boolean;
     };
     format?: 'jpeg' | 'jpg' | 'png' | 'gif' | 'webp' | 'avif' | 'heif' | 'tiff' | 'raw' | jpeg | png | gif | webp | avif | heif;
     blurhash?: boolean | BlurhashOptions;

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

@@ -6,11 +6,11 @@
  */
 import type { LucidRow } from '@adonisjs/lucid/types/model';
 import type { Attachment } from './attachment.js';
-export type AttributeOfModelWithAttachment = {
+export type AttributeOfRowWithAttachment = {
     attached: Attachment[];
     detached: Attachment[];
     dirtied: string[];
 };
-export type ModelWithAttachment = LucidRow & {
-    $attachments: AttributeOfModelWithAttachment;
+export type RowWithAttachment = LucidRow & {
+    $attachments: AttributeOfRowWithAttachment;
 };

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

@@ -0,0 +1,5 @@
+import type { AttachmentVariants } from '@jrmc/adonis-attachment';
+export type RegenerateOptions = {
+    attributes?: string[];
+    variants?: (keyof AttachmentVariants)[];
+};

package/build/src/types/regenerate.js

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

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

@@ -1,7 +1,7 @@
 import type { Attachment } from './attachment.js';
-import type { ModelWithAttachment } from './mixin.js';
+import type { RowWithAttachment } from './mixin.js';
 export interface Record {
-    model: ModelWithAttachment;
+    row: RowWithAttachment;
     commit(): Promise<void>;
     rollback(): Promise<void>;
     persist(): Promise<void>;
@@ -13,5 +13,6 @@ export interface Record {
     getAttachments(options: {
         attributeName: string;
         requiredOriginal?: boolean;
+        requiredDirty?: boolean;
     }): Attachment[];
 }

package/build/src/utils/helpers.d.ts

@@ -13,3 +13,4 @@ export declare function streamToTempFile(input: NodeJS.ReadableStream): Promise<
 export declare function downloadToTempFile(input: URL): Promise<string>;
 export declare function isBase64(str: string): boolean;
 export declare function imageToBlurhash(input: Input, options?: BlurhashOptions): Promise<string>;
+export declare function extractPathParameters(path: string): string[];

package/build/src/utils/helpers.js

@@ -110,3 +110,12 @@ export function imageToBlurhash(input, options) {
         }
     });
 }
+export function extractPathParameters(path) {
+    const paramRegex = /:(\w+)/g;
+    const parameters = [];
+    let match;
+    while ((match = paramRegex.exec(path)) !== null) {
+        parameters.push(match[1]);
+    }
+    return parameters;
+}

package/package.json

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