@jrmc/adonis-attachment 3.3.0-beta.2 → 3.3.0-beta.4

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/src/adapters/blurhash.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    encode(pixels: Uint8ClampedArray, width: number, height: number, componentX: number, componentY: number): Promise<string>;
+};
+export default _default;

package/build/src/adapters/blurhash.js

@@ -0,0 +1,6 @@
+import { encode } from 'blurhash';
+export default {
+    async encode(pixels, width, height, componentX, componentY) {
+        return encode(pixels, width, height, componentX, componentY);
+    },
+};

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);
@@ -129,6 +135,7 @@ export class Attachment extends AttachmentBase {
                     mimeType: v.mimeType,
                     meta: v.meta,
                     size: v.size,
+                    blurhash: v.blurhash,
                 };
             });
         }

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
@@ -32,6 +33,7 @@ export declare class AttachmentBase implements AttachmentBaseInterface {
     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);
     }
     /**
@@ -70,6 +81,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/converter_manager.js

@@ -1,8 +1,9 @@
+import logger from '@adonisjs/core/services/logger';
 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 { encodeImageToBlurhash } from './utils/helpers.js';
+import { imageToBlurhash } from './utils/helpers.js';
 export class ConverterManager {
     #record;
     #attributeName;
@@ -20,11 +21,11 @@ export class ConverterManager {
         const id = this.#record.model.$attributes['id'];
         const data = {};
         if (this.#options.variants) {
-            for (const option of this.#options.variants) {
+            for await (const option of this.#options.variants) {
                 const converter = (await attachmentManager.getConverter(option));
                 if (attachments && converter) {
-                    for (let i = 0; i < attachments.length; i++) {
-                        const input = attachments[i].input;
+                    for await (const attachment of attachments) {
+                        const input = attachment.input;
                         const output = await converter.handle({
                             input,
                             options: converter.options,
@@ -32,10 +33,21 @@ export class ConverterManager {
                         if (output === undefined) {
                             throw new errors.E_CANNOT_PATH_BY_CONVERTER();
                         }
-                        const variant = await attachments[i].createVariant(option, output);
+                        const variant = await attachment.createVariant(option, output);
                         if (converter.options.blurhash) {
-                            const options = typeof converter.options.blurhash !== 'boolean' ? converter.options.blurhash : undefined;
-                            variant.blurhash = await encodeImageToBlurhash(variant.input, options);
+                            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);
                     }
@@ -58,10 +70,10 @@ export class ConverterManager {
         });
         try {
             await trx.query().from(Model.table).where('id', id).update(data);
-            return await trx.commit();
+            return trx.commit();
         }
         catch (error) {
-            return await trx.rollback();
+            return trx.rollback();
         }
     }
 }

package/build/src/services/record_with_attachment.js

@@ -57,7 +57,7 @@ export default class Record {
                  * file.
                  */
                 if (newAttachments[i]) {
-                    newAttachments[i].setOptions(options);
+                    newAttachments[i].setOptions(options).makeFolder(this.#model);
                     this.#model.$attachments.attached.push(newAttachments[i]);
                     /**
                      * Also write the file to the disk right away
@@ -106,7 +106,7 @@ export default class Record {
          * For all properties Attachment
          * Launch async generation variants
          */
-        await Promise.allSettled(attachmentAttributeNames.map((name) => {
+        for await (const name of attachmentAttributeNames) {
             const record = this;
             attachmentManager.queue.push({
                 name: `${this.#model.constructor.name}-${name}`,
@@ -124,7 +124,7 @@ export default class Record {
                     }
                 },
             });
-        }));
+        }
     }
     async detach() {
         const attachmentAttributeNames = this.#getDirtyAttributeNamesOfAttachment();
@@ -214,7 +214,9 @@ export default class Record {
             const dirtyValue = this.#model.$dirty[name];
             const originalValue = this.#model.$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);
+                (Array.isArray(dirtyValue) &&
+                    dirtyValue.every((item) => item instanceof Attachment) &&
+                    dirtyValue.length);
             const isOriginalAttachment = originalValue instanceof Attachment ||
                 (Array.isArray(originalValue) && originalValue.every((item) => item instanceof Attachment));
             return isDirtyAttachment || isOriginalAttachment;

package/build/src/types/attachment.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 } from '@adonisjs/drive/types';
 import type { Exif, Input } from './input.js';
 import type { Disk } from '@adonisjs/drive';
@@ -21,7 +22,8 @@ export type AttachmentBase = {
     meta?: Exif;
     originalPath?: string;
     url?: string;
-    options?: LucidOptions;
+    options: LucidOptions;
+    makeFolder(record?: LucidRow): void;
     getDisk(): Disk;
     getUrl(): Promise<string>;
     getSignedUrl(signedUrlOptions?: SignedURLOptions): Promise<string>;
@@ -46,7 +48,7 @@ export type Variant = AttachmentBase & {
 };
 export type LucidOptions = {
     disk?: string;
-    folder?: string;
+    folder?: string | ((record?: LucidRow) => string);
     preComputeUrl?: boolean;
     variants?: (keyof AttachmentVariants)[];
     rename?: boolean;

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

@@ -24,47 +24,47 @@ export type ConverterAttributes = {
 };
 export type BlurhashOptions = {
     enabled: boolean;
-    componentX: number;
-    componentY: number;
+    componentX: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    componentY: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 };
 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 +73,7 @@ type gif = {
         interPaletteMaxError?: number;
         loop?: number;
         delay?: number | number[];
-        force?: Boolean;
+        force?: boolean;
     };
 };
 type webp = {
@@ -81,23 +81,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 +108,7 @@ type heif = {
     options: {
         compression?: string;
         quality?: number;
-        lossless?: Boolean;
+        lossless?: boolean;
         effort?: number;
         chromaSubsampling?: string;
         bitdepth?: number;
@@ -127,9 +127,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/utils/helpers.d.ts

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

package/build/src/utils/helpers.js

@@ -11,7 +11,7 @@ import fs from 'node:fs/promises';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import { createWriteStream } from 'node:fs';
-import { encode } from 'blurhash';
+import BlurhashAdapter from '../adapters/blurhash.js';
 import * as errors from '../errors.js';
 const streamPipeline = promisify(pipeline);
 export function cleanObject(obj) {
@@ -92,7 +92,7 @@ export function isBase64(str) {
         return false;
     }
 }
-export function encodeImageToBlurhash(input, options) {
+export function imageToBlurhash(input, options) {
     const { componentX, componentY } = options || { componentX: 4, componentY: 4 };
     return new Promise(async (resolve, reject) => {
         try {
@@ -102,12 +102,20 @@ export function encodeImageToBlurhash(input, options) {
                 .raw()
                 .ensureAlpha()
                 .toBuffer({ resolveWithObject: true });
-            return resolve(encode(new Uint8ClampedArray(pixels), metadata.width, metadata.height, componentX, componentY));
+            const blurhash = BlurhashAdapter.encode(new Uint8ClampedArray(pixels), metadata.width, metadata.height, componentX, componentY);
+            return resolve(blurhash);
         }
         catch (error) {
-            console.log('--------------');
-            console.log(error);
             return reject(error);
         }
     });
 }
+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.2",
+  "version": "3.3.0-beta.4",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -96,6 +96,7 @@
     "luxon": "^3.5.0",
     "prettier": "^3.4.2",
     "sharp": "^0.33.5",
+    "sinon": "^19.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "vitepress": "^1.5.0"