@jrmc/adonis-attachment 3.0.0 → 3.2.0

package/build/src/mixins/attachmentable.js

@@ -10,101 +10,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { beforeSave, afterSave, beforeDelete, afterFind, afterFetch, afterPaginate, } from '@adonisjs/lucid/orm';
-import { persistAttachment, commit, rollback, generateVariants, preComputeUrl, } from '../utils/actions.js';
-import { clone, getAttachmentAttributeNames, getDirtyAttachmentAttributeNames, } from '../utils/helpers.js';
+import { beforeSave, beforeFind, beforeFetch, beforePaginate, beforeCreate, } from '@adonisjs/lucid/orm';
+import { clone } from '../utils/helpers.js';
 import { defaultStateAttributeMixin } from '../utils/default_values.js';
-export const Attachmentable = (superclass) => {
+import logger from '@adonisjs/core/services/logger';
+export function Attachmentable(superclass) {
     class ModelWithAttachment extends superclass {
         $attachments = clone(defaultStateAttributeMixin);
-        static async afterFindHook(modelInstance) {
-            const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-            await Promise.all(attachmentAttributeNames.map((attributeName) => {
-                return preComputeUrl(modelInstance, attributeName);
-            }));
-        }
-        static async afterFetchHook(modelInstances) {
-            await Promise.all(modelInstances.map((row) => this.afterFindHook(row)));
-        }
-        static async beforeSaveHook(modelInstance) {
-            const attachmentAttributeNames = getDirtyAttachmentAttributeNames(modelInstance);
-            /**
-             * Empty previous $attachments
-             */
-            modelInstance.$attachments = clone(defaultStateAttributeMixin);
-            /**
-             * Set attributes Attachment type modified
-             */
-            attachmentAttributeNames.forEach((attributeName) => modelInstance.$attachments.attributesModified.push(attributeName));
-            /**
-             * Persist attachments before saving the model to the database. This
-             * way if file saving fails we will not write anything to the
-             * database
-             */
-            await Promise.all(attachmentAttributeNames.map((attributeName) => persistAttachment(modelInstance, attributeName)));
-            try {
-                if (modelInstance.$trx) {
-                    modelInstance.$trx.after('commit', () => commit(modelInstance));
-                    modelInstance.$trx.after('rollback', () => rollback(modelInstance));
-                }
-                else {
-                    await commit(modelInstance);
-                }
-            }
-            catch (error) {
-                await rollback(modelInstance);
-                throw error;
-            }
-        }
-        static async afterSaveHook(modelInstance) {
-            const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-            /**
-             * For all properties Attachment
-             * Launch async generation variants
-             */
-            await Promise.all(attachmentAttributeNames.map((attributeName) => {
-                if (modelInstance.$attachments.attributesModified.includes(attributeName)) {
-                    return generateVariants(modelInstance, attributeName);
-                }
-            }));
-        }
-        static async beforeDeleteHook(modelInstance) {
-            const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
-            /**
-             * Mark all attachments for deletion
-             */
-            attachmentAttributeNames.map((attributeName) => {
-                if (modelInstance.$attributes[attributeName]) {
-                    modelInstance.$attachments.detached.push(modelInstance.$attributes[attributeName]);
-                }
-            });
-            /**
-             * If model is using transaction, then wait for the transaction
-             * to settle
-             */
-            if (modelInstance.$trx) {
-                modelInstance.$trx.after('commit', () => commit(modelInstance));
-            }
-            else {
-                await commit(modelInstance);
-            }
+        static async warn() {
+            logger.warn(`The "Attachmentable" mixin is deprecated and may be removed in a future version.`);
         }
     }
     __decorate([
-        afterFind()
-    ], ModelWithAttachment, "afterFindHook", null);
-    __decorate([
-        afterFetch(),
-        afterPaginate()
-    ], ModelWithAttachment, "afterFetchHook", null);
-    __decorate([
+        beforeCreate(),
+        beforeFind(),
+        beforeFetch(),
+        beforePaginate(),
         beforeSave()
-    ], ModelWithAttachment, "beforeSaveHook", null);
-    __decorate([
-        afterSave()
-    ], ModelWithAttachment, "afterSaveHook", null);
-    __decorate([
-        beforeDelete()
-    ], ModelWithAttachment, "beforeDeleteHook", null);
+    ], ModelWithAttachment, "warn", null);
     return ModelWithAttachment;
-};
+}

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

@@ -86,6 +86,27 @@ type webp = {
         force?: Boolean;
     };
 };
+type avif = {
+    format: 'avif';
+    options: {
+        quality?: number;
+        lossless?: Boolean;
+        effort?: number;
+        chromaSubsampling?: string;
+        bitdepth?: number;
+    };
+};
+type heif = {
+    format: 'heif';
+    options: {
+        compression?: string;
+        quality?: number;
+        lossless?: Boolean;
+        effort?: number;
+        chromaSubsampling?: string;
+        bitdepth?: number;
+    };
+};
 export type ConverterOptions = {
     resize?: number | {
         width?: number;
@@ -103,6 +124,6 @@ export type ConverterOptions = {
         withoutReduction?: Boolean;
         fastShrinkOnLoad?: Boolean;
     };
-    format?: string | jpeg | png | gif | webp;
+    format?: 'jpeg' | 'jpg' | 'png' | 'gif' | 'webp' | 'avif' | 'heif' | 'tiff' | 'raw' | jpeg | png | gif | webp | avif | heif;
 };
 export {};

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

@@ -21,4 +21,9 @@ export type Exif = {
         height: number;
     };
 };
+export type Meta = {
+    extname: string;
+    mimeType: string;
+    size: number;
+};
 export type Input = Buffer | string;

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

@@ -5,19 +5,14 @@
  * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
  */
 import type { LucidOptions } from '../types/attachment.js';
-import type { Input } from '../types/input.js';
 import type { ModelWithAttachment } from '../types/mixin.js';
 export declare function getAttachmentAttributeNames(modelInstance: ModelWithAttachment): string[];
 export declare function getDirtyAttachmentAttributeNames(modelInstance: ModelWithAttachment): string[];
 export declare function getOptions(modelInstance: ModelWithAttachment, attributeName: string): LucidOptions;
-export declare function createAttachmentAttributes(input: Input, name?: string): Promise<{
-    originalName: string;
-    extname: import("file-type").FileExtension;
-    mimeType: import("file-type").MimeType;
-    size: number;
-}>;
 export declare function cleanObject(obj: any): any;
 export declare function clone(object: Object): any;
 export declare function use(module: string): Promise<any>;
 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;

package/build/src/utils/helpers.js

@@ -6,13 +6,15 @@
  */
 import os from 'node:os';
 import path from 'node:path';
-import fs from 'fs/promises';
-import { cuid } from '@adonisjs/core/helpers';
-import string from '@adonisjs/core/helpers/string';
-import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
+import https from 'node:https';
+import fs from 'node:fs/promises';
+import { pipeline } from 'node:stream';
+import { promisify } from 'node:util';
+import { createWriteStream } from 'node:fs';
 import { Attachment } from '../attachments/attachment.js';
 import * as errors from '../errors.js';
 import { optionsSym } from './symbols.js';
+const streamPipeline = promisify(pipeline);
 export function getAttachmentAttributeNames(modelInstance) {
     return Object.keys(modelInstance.$attributes).filter((attr) => modelInstance.$attributes[attr] instanceof Attachment);
 }
@@ -23,27 +25,6 @@ export function getDirtyAttachmentAttributeNames(modelInstance) {
 export function getOptions(modelInstance, attributeName) {
     return modelInstance.constructor.prototype[optionsSym]?.[attributeName];
 }
-export async function createAttachmentAttributes(input, name) {
-    let fileType;
-    if (Buffer.isBuffer(input)) {
-        fileType = await fileTypeFromBuffer(input);
-    }
-    else {
-        fileType = await fileTypeFromFile(input);
-    }
-    if (name) {
-        name = string.slug(name);
-    }
-    else {
-        name = `${cuid()}.${fileType.ext}`;
-    }
-    return {
-        originalName: name,
-        extname: fileType.ext,
-        mimeType: fileType.mime,
-        size: input.length,
-    };
-}
 export function cleanObject(obj) {
     if (obj === null || typeof obj !== 'object') {
         return obj;
@@ -83,6 +64,37 @@ export async function bufferToTempFile(input) {
     await fs.writeFile(tempFilePath, input);
     return tempFilePath;
 }
+// TODO
+// gestion des erreurs
+export async function streamToTempFile(input) {
+    const folder = os.tmpdir();
+    const tempFilePath = path.join(folder, `tempfile-${Date.now()}.tmp`);
+    const writeStream = createWriteStream(tempFilePath);
+    try {
+        await streamPipeline(input, writeStream);
+        return tempFilePath;
+    }
+    catch (err) {
+        throw new errors.E_CANNOT_GENERATE_TEMP_FILE([err.message]);
+    }
+}
+export async function downloadToTempFile(input) {
+    return await new Promise((resolve) => {
+        https
+            .get(input, (response) => {
+            if (response.statusCode === 200) {
+                resolve(streamToTempFile(response));
+            }
+            else {
+                // reject(`${response.statusCode}`)
+                throw new errors.E_CANNOT_GENERATE_TEMP_FILE(['']);
+            }
+        })
+            .on('error', (err) => {
+            throw new errors.E_CANNOT_GENERATE_TEMP_FILE([err.message]);
+        });
+    });
+}
 export function isBase64(str) {
     const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
     if (!base64Regex.test(str)) {

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

@@ -0,0 +1,11 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export declare const afterFindHook: (instance: unknown) => Promise<void>;
+export declare const afterFetchHook: (instance: unknown) => Promise<void>;
+export declare const beforeSaveHook: (instance: unknown) => Promise<void>;
+export declare const afterSaveHook: (instance: unknown) => Promise<void>;
+export declare const beforeDeleteHook: (instance: unknown) => Promise<void>;

package/build/src/utils/hooks.js

@@ -0,0 +1,92 @@
+/**
+ * @jrmc/adonis-attachment
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { persistAttachment, commit, rollback, generateVariants, preComputeUrl, } from '../utils/actions.js';
+import { clone, getAttachmentAttributeNames, getDirtyAttachmentAttributeNames, } from '../utils/helpers.js';
+import { defaultStateAttributeMixin } from '../utils/default_values.js';
+// @afterFind()
+export const afterFindHook = async (instance) => {
+    const modelInstance = instance;
+    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
+    await Promise.all(attachmentAttributeNames.map((attributeName) => {
+        return preComputeUrl(modelInstance, attributeName);
+    }));
+};
+// @afterFetch()
+// @afterPaginate()
+export const afterFetchHook = async (instance) => {
+    const modelInstances = instance;
+    await Promise.all(modelInstances.map((row) => afterFindHook(row)));
+};
+// @beforeSave()
+export const beforeSaveHook = async (instance) => {
+    const modelInstance = instance;
+    const attachmentAttributeNames = getDirtyAttachmentAttributeNames(modelInstance);
+    /**
+     * Empty previous $attachments
+     */
+    modelInstance.$attachments = clone(defaultStateAttributeMixin);
+    /**
+     * Set attributes Attachment type modified
+     */
+    attachmentAttributeNames.forEach((attributeName) => modelInstance.$attachments.attributesModified.push(attributeName));
+    /**
+     * Persist attachments before saving the model to the database. This
+     * way if file saving fails we will not write anything to the
+     * database
+     */
+    await Promise.all(attachmentAttributeNames.map((attributeName) => persistAttachment(modelInstance, attributeName)));
+    try {
+        if (modelInstance.$trx) {
+            modelInstance.$trx.after('commit', () => commit(modelInstance));
+            modelInstance.$trx.after('rollback', () => rollback(modelInstance));
+        }
+        else {
+            await commit(modelInstance);
+        }
+    }
+    catch (error) {
+        await rollback(modelInstance);
+        throw error;
+    }
+};
+// @afterSave()
+export const afterSaveHook = async (instance) => {
+    const modelInstance = instance;
+    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
+    /**
+     * For all properties Attachment
+     * Launch async generation variants
+     */
+    await Promise.all(attachmentAttributeNames.map((attributeName) => {
+        if (modelInstance.$attachments.attributesModified.includes(attributeName)) {
+            return generateVariants(modelInstance, attributeName);
+        }
+    }));
+};
+// @beforeDelete()
+export const beforeDeleteHook = async (instance) => {
+    const modelInstance = instance;
+    const attachmentAttributeNames = getAttachmentAttributeNames(modelInstance);
+    /**
+     * Mark all attachments for deletion
+     */
+    attachmentAttributeNames.map((attributeName) => {
+        if (modelInstance.$attributes[attributeName]) {
+            modelInstance.$attachments.detached.push(modelInstance.$attributes[attributeName]);
+        }
+    });
+    /**
+     * If model is using transaction, then wait for the transaction
+     * to settle
+     */
+    if (modelInstance.$trx) {
+        modelInstance.$trx.after('commit', () => commit(modelInstance));
+    }
+    else {
+        await commit(modelInstance);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrmc/adonis-attachment",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "type": "module",
   "description": "Turn any field on your Lucid model to an attachment data type",
   "engines": {
@@ -46,7 +46,9 @@
     "format": "prettier --write .",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "docs:preview": "vitepress preview docs",
+    "test": "c8 npm run quick:test",
+    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts"
   },
   "exports": {
     ".": "./build/index.js",
@@ -62,23 +64,39 @@
     "./attachment_provider": "./build/providers/attachment_provider.js"
   },
   "dependencies": {
-    "@poppinss/defer": "^1.1.0",
-    "exifreader": "^4.23.3",
-    "file-type": "^19.4.0"
+    "@poppinss/defer": "^1.1.1",
+    "exifreader": "^4.26.0",
+    "file-type": "^19.6.0",
+    "mime-types": "^2.1.35"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^7.7.0",
-    "@adonisjs/core": "^6.12.1",
+    "@adonisjs/assembler": "^7.8.2",
+    "@adonisjs/core": "^6.17.1",
     "@adonisjs/drive": "^3.2.0",
-    "@adonisjs/lucid": "^20.6.0",
-    "@adonisjs/prettier-config": "^1.3.0",
-    "@adonisjs/tsconfig": "^1.3.0",
-    "@types/node": "^22.2.0",
+    "@adonisjs/lucid": "^21.6.0",
+    "@adonisjs/prettier-config": "^1.4.0",
+    "@adonisjs/tsconfig": "^1.4.0",
+    "@japa/assert": "^4.0.1",
+    "@japa/expect-type": "^2.0.3",
+    "@japa/file-system": "^2.3.2",
+    "@japa/plugin-adonisjs": "^4.0.0",
+    "@japa/runner": "^4.1.0",
+    "@poppinss/utils": "^6.9.2",
+    "@swc/core": "^1.10.7",
+    "@types/luxon": "^3.4.2",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^22.10.7",
+    "@types/sinon": "^17.0.3",
+    "better-sqlite3": "^11.8.0",
+    "c8": "^10.1.3",
     "copyfiles": "^2.4.1",
-    "del-cli": "^5.1.0",
-    "prettier": "^3.3.3",
-    "typescript": "^5.5.4",
-    "vitepress": "^1.3.3"
+    "del-cli": "^6.0.0",
+    "flydrive": "^1.1.0",
+    "luxon": "^3.5.0",
+    "prettier": "^3.4.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3",
+    "vitepress": "^1.5.0"
   },
   "peerDependencies": {
     "@adonisjs/core": "^6.12.1",
@@ -86,6 +104,15 @@
     "@adonisjs/lucid": "^20.6.0 || ^21.0.0"
   },
   "prettier": "@adonisjs/prettier-config",
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
   "publishConfig": {
     "access": "public",
     "tag": "latest"