@byline/core 1.2.1 → 1.3.0

package/dist/@types/storage-types.d.ts

@@ -38,6 +38,21 @@ export interface UploadFileOptions {
      * Providers may use this to namespace storage paths.
      */
     collection?: string;
+    /**
+     * Explicit, fully-qualified storage path / object key the provider must
+     * write to verbatim. When set, providers MUST place the file at exactly
+     * this path — no UUID prefix, year/month rewrite, or `pathPrefix` injection.
+     *
+     * Used by the image-variant pipeline (`generateImageVariants`) to write
+     * sibling files alongside an already-stored original (e.g. so the
+     * `thumbnail` variant of `media/2026/05/abc-photo.jpg` lands at
+     * `media/2026/05/abc-photo-thumbnail.webp`).
+     *
+     * Always POSIX-style (forward slashes), no leading slash. Callers are
+     * responsible for sanitisation and collision-avoidance — providers do
+     * not second-guess the path when this is set.
+     */
+    targetStoragePath?: string;
 }
 /**
  * The pluggable file-storage interface.

package/dist/image/image-processor.d.ts

@@ -6,6 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { ImageSize } from '../@types/collection-types.js';
+import type { IStorageProvider, StoredFileLocation } from '../@types/storage-types.js';
 import type { BylineLogger } from '../logger/index.js';
 export interface ImageMeta {
     width: number | null;
@@ -35,11 +36,16 @@ export declare function isBypassMimeType(mimeType: string): boolean;
  */
 export declare function extractImageMeta(buffer: Buffer, mimeType: string): Promise<ImageMeta>;
 /**
- * Generate the named image variants (sizes) defined in `UploadConfig.sizes`.
+ * Generate the named image variants (sizes) defined in `UploadConfig.sizes`
+ * and persist them through the configured `IStorageProvider`.
  *
  * - SVG and GIF files are skipped entirely (bypass types).
- * - Each variant is written as a sibling file to the original, using the
- *   naming convention: `<basename>-<variantName>.<ext>`
+ * - Each variant is uploaded as a sibling object to `storedFile.storagePath`,
+ *   using the naming convention: `<dir>/<basename>-<variantName>.<ext>`
+ *   (POSIX paths — both local filesystem keys and S3 object keys).
+ * - Variant bytes are produced in-memory by Sharp and written via
+ *   `storage.upload(buffer, { targetStoragePath })` — no direct filesystem
+ *   access, so the function is provider-agnostic.
  * - Returns an array of `ImageVariantResult` describing what was created.
  */
-export declare function generateImageVariants(sourceBuffer: Buffer, mimeType: string, absoluteOriginalPath: string, storageBaseDir: string, sizes: ImageSize[], logger?: BylineLogger): Promise<ImageVariantResult[]>;
+export declare function generateImageVariants(sourceBuffer: Buffer, mimeType: string, storedFile: StoredFileLocation, storage: IStorageProvider, sizes: ImageSize[], logger?: BylineLogger): Promise<ImageVariantResult[]>;

package/dist/image/image-processor.js

@@ -5,7 +5,6 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-import fs from 'node:fs';
 import path from 'node:path';
 // Sharp ships its own types; no @types/sharp needed.
 import sharp from 'sharp';
@@ -67,30 +66,52 @@ function tryParseSvgDimensions(buffer) {
 // Variant generation
 // ---------------------------------------------------------------------------
 /**
- * Generate the named image variants (sizes) defined in `UploadConfig.sizes`.
+ * Map a Sharp output format keyword to the corresponding image MIME type.
+ * Unknown formats fall back to `application/octet-stream` — the storage
+ * provider will accept it; only the served `Content-Type` is affected.
+ */
+function mimeTypeForFormat(format) {
+    switch (format) {
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        case 'webp':
+            return 'image/webp';
+        case 'avif':
+            return 'image/avif';
+        default:
+            return 'application/octet-stream';
+    }
+}
+/**
+ * Generate the named image variants (sizes) defined in `UploadConfig.sizes`
+ * and persist them through the configured `IStorageProvider`.
  *
  * - SVG and GIF files are skipped entirely (bypass types).
- * - Each variant is written as a sibling file to the original, using the
- *   naming convention: `<basename>-<variantName>.<ext>`
+ * - Each variant is uploaded as a sibling object to `storedFile.storagePath`,
+ *   using the naming convention: `<dir>/<basename>-<variantName>.<ext>`
+ *   (POSIX paths — both local filesystem keys and S3 object keys).
+ * - Variant bytes are produced in-memory by Sharp and written via
+ *   `storage.upload(buffer, { targetStoragePath })` — no direct filesystem
+ *   access, so the function is provider-agnostic.
  * - Returns an array of `ImageVariantResult` describing what was created.
  */
-export async function generateImageVariants(sourceBuffer, mimeType, absoluteOriginalPath, storageBaseDir, sizes, logger) {
+export async function generateImageVariants(sourceBuffer, mimeType, storedFile, storage, sizes, logger) {
     if (isBypassMimeType(mimeType) || sizes.length === 0) {
         return [];
     }
-    const originalExt = path.extname(absoluteOriginalPath);
-    const originalBase = path.basename(absoluteOriginalPath, originalExt);
-    const variantDir = path.dirname(absoluteOriginalPath);
+    // Storage paths are POSIX-style across providers; use `path.posix` so
+    // Windows local-fs hosts don't introduce backslashes into S3 object keys.
+    const sourcePath = storedFile.storagePath;
+    const originalExt = path.posix.extname(sourcePath);
+    const originalBase = path.posix.basename(sourcePath, originalExt);
+    const variantDir = path.posix.dirname(sourcePath);
     const variants = [];
     for (const size of sizes) {
         const outputFormat = size.format ?? 'webp';
-        const outputExt = `.${outputFormat}`;
-        const variantFilename = `${originalBase}-${size.name}${outputExt}`;
-        const variantAbsolutePath = path.join(variantDir, variantFilename);
-        // Derive the storage-relative path (relative to storageBaseDir).
-        const variantStoragePath = path
-            .relative(storageBaseDir, variantAbsolutePath)
-            .replace(/\\/g, '/');
+        const variantFilename = `${originalBase}-${size.name}.${outputFormat}`;
+        const variantStoragePath = variantDir === '.' ? variantFilename : `${variantDir}/${variantFilename}`;
         try {
             let pipeline = sharp(sourceBuffer);
             const resizeOptions = {
@@ -118,9 +139,13 @@ export async function generateImageVariants(sourceBuffer, mimeType, absoluteOrig
                     pipeline = pipeline.webp({ quality: size.quality ?? 85 });
             }
             const variantBuffer = await pipeline.toBuffer();
-            fs.mkdirSync(path.dirname(variantAbsolutePath), { recursive: true });
-            await fs.promises.writeFile(variantAbsolutePath, variantBuffer);
             const sharpMeta = await sharp(variantBuffer).metadata();
+            await storage.upload(variantBuffer, {
+                filename: variantFilename,
+                mimeType: mimeTypeForFormat(outputFormat),
+                size: variantBuffer.byteLength,
+                targetStoragePath: variantStoragePath,
+            });
             variants.push({
                 name: size.name,
                 storagePath: variantStoragePath,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/core",
   "private": false,
   "license": "MPL-2.0",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -79,7 +79,7 @@
     "sharp": "^0.34.5",
     "uuid": "^14.0.0",
     "zod": "^4.4.2",
-    "@byline/auth": "1.2.1"
+    "@byline/auth": "1.3.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.14",