@howells/stow-next 0.1.0

package/dist/index.js

@@ -0,0 +1,383 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createConfirmHandler: () => createConfirmHandler,
+  createCorsPreflightHandler: () => createCorsPreflightHandler,
+  createPresignHandler: () => createPresignHandler,
+  createStowLoader: () => createStowLoader,
+  createUploadHandler: () => createUploadHandler,
+  stowLoader: () => stowLoader
+});
+module.exports = __toCommonJS(index_exports);
+var import_server = require("next/server");
+
+// src/image-loader.ts
+var STOW_DOMAIN_PATTERN = /\.stow\.sh$/;
+function isStowUrl(src) {
+  try {
+    const url = new URL(src);
+    return STOW_DOMAIN_PATTERN.test(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function buildTransformParams(width, quality, config) {
+  const params = new URLSearchParams();
+  params.set("w", width.toString());
+  if (config.aspectRatio) {
+    params.set("h", Math.round(width / config.aspectRatio).toString());
+  }
+  params.set("q", quality.toString());
+  if (config.fit) {
+    params.set("fit", config.fit);
+  }
+  if (config.gravity) {
+    params.set("gravity", config.gravity);
+  }
+  if (config.defaultFormat) {
+    params.set("f", config.defaultFormat);
+  }
+  return params;
+}
+function transformStowUrl(src, baseUrl, params) {
+  const url = new URL(src, baseUrl);
+  const pathname = url.pathname;
+  if (pathname.startsWith("/files/")) {
+    const transformPath = pathname.replace("/files/", "/transform/");
+    return `${baseUrl}${transformPath}?${params.toString()}`;
+  }
+  if (pathname.startsWith("/transform/")) {
+    return `${baseUrl}${pathname}?${params.toString()}`;
+  }
+  return `${src}${src.includes("?") ? "&" : "?"}${params.toString()}`;
+}
+function createStowLoader(config = {}) {
+  const {
+    baseUrl = "https://stow.sh",
+    defaultQuality = 75,
+    defaultFormat,
+    proxySlug,
+    fit,
+    gravity,
+    aspectRatio
+  } = config;
+  return function stowLoader2({
+    src,
+    width,
+    quality
+  }) {
+    const resolvedQuality = quality || defaultQuality;
+    const paramConfig = { defaultFormat, fit, gravity, aspectRatio };
+    if (isStowUrl(src)) {
+      const params = buildTransformParams(width, resolvedQuality, paramConfig);
+      return `${src}${src.includes("?") ? "&" : "?"}${params.toString()}`;
+    }
+    if (src.startsWith(baseUrl) || src.startsWith("/files/")) {
+      const params = buildTransformParams(width, resolvedQuality, paramConfig);
+      return transformStowUrl(src, baseUrl, params);
+    }
+    if (proxySlug && (src.startsWith("http://") || src.startsWith("https://"))) {
+      const params = new URLSearchParams();
+      params.set("url", src);
+      params.set("w", width.toString());
+      if (aspectRatio) {
+        params.set("h", Math.round(width / aspectRatio).toString());
+      }
+      params.set("q", resolvedQuality.toString());
+      if (fit) {
+        params.set("fit", fit);
+      }
+      if (gravity) {
+        params.set("gravity", gravity);
+      }
+      if (defaultFormat) {
+        params.set("f", defaultFormat);
+      }
+      return `https://proxy.stow.sh/${proxySlug}/?${params.toString()}`;
+    }
+    return src;
+  };
+}
+var stowLoader = createStowLoader();
+
+// src/index.ts
+var DEFAULT_CORS = {
+  origin: "*",
+  methods: ["POST", "OPTIONS"],
+  allowedHeaders: ["Content-Type"],
+  maxAge: 86400
+};
+function getLocalConfirmPath(pathname) {
+  if (pathname.endsWith("/presign")) {
+    const PRESIGN_SUFFIX_LENGTH = 7;
+    return `${pathname.slice(0, -PRESIGN_SUFFIX_LENGTH)}confirm`;
+  }
+  return pathname.endsWith("/") ? `${pathname}confirm` : `${pathname}/confirm`;
+}
+function withCors(response, config) {
+  const cors = { ...DEFAULT_CORS, ...config };
+  const origin = Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin;
+  response.headers.set("Access-Control-Allow-Origin", origin);
+  response.headers.set("Access-Control-Allow-Methods", cors.methods.join(", "));
+  response.headers.set(
+    "Access-Control-Allow-Headers",
+    cors.allowedHeaders.join(", ")
+  );
+  response.headers.set("Access-Control-Max-Age", cors.maxAge.toString());
+  return response;
+}
+function createCorsPreflightHandler(config) {
+  return function handler() {
+    return withCors(new import_server.NextResponse(null, { status: 204 }), config);
+  };
+}
+function createPresignHandler(config) {
+  const corsEnabled = config.cors !== false;
+  const corsConfig = config.cors === false ? void 0 : config.cors;
+  const respond = (data, status) => {
+    const response = import_server.NextResponse.json(data, { status });
+    return corsEnabled ? withCors(response, corsConfig) : response;
+  };
+  async function handler(request) {
+    if (request.method === "OPTIONS") {
+      const response = new import_server.NextResponse(null, { status: 204 });
+      return corsEnabled ? withCors(response, corsConfig) : response;
+    }
+    try {
+      const body = await request.json();
+      const { filename, contentType, size, route: requestRoute } = body;
+      if (!filename || typeof filename !== "string") {
+        return respond({ error: "filename is required" }, 400);
+      }
+      if (!contentType || typeof contentType !== "string") {
+        return respond({ error: "contentType is required" }, 400);
+      }
+      if (typeof size !== "number" || size <= 0) {
+        return respond({ error: "size must be a positive number" }, 400);
+      }
+      if (config.maxSize && size > config.maxSize) {
+        return respond(
+          {
+            error: `File too large. Maximum size is ${formatBytes(config.maxSize)}`
+          },
+          400
+        );
+      }
+      if (config.allowedTypes && config.allowedTypes.length > 0) {
+        const isAllowed = config.allowedTypes.some((type) => {
+          if (type.endsWith("/*")) {
+            const prefix = type.slice(0, -1);
+            return contentType.startsWith(prefix);
+          }
+          return contentType === type;
+        });
+        if (!isAllowed) {
+          return respond(
+            { error: `File type "${contentType}" is not allowed` },
+            400
+          );
+        }
+      }
+      if (config.validate) {
+        const validationResult = await config.validate({
+          filename,
+          contentType,
+          size
+        });
+        if (validationResult !== true) {
+          return respond(
+            {
+              error: typeof validationResult === "string" ? validationResult : "Validation failed"
+            },
+            400
+          );
+        }
+      }
+      const route = requestRoute || config.route;
+      const result = await config.stow.getPresignedUrl({
+        filename,
+        contentType,
+        size,
+        route
+      });
+      if ("dedupe" in result && result.dedupe) {
+        return respond(result, 200);
+      }
+      return respond(
+        {
+          ...result,
+          confirmUrl: getLocalConfirmPath(request.nextUrl.pathname)
+        },
+        200
+      );
+    } catch (error) {
+      console.error("Presign error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return respond({ error: error.message }, status >= 400 ? status : 500);
+      }
+      return respond({ error: "Presign failed" }, 500);
+    }
+  }
+  return handler;
+}
+function createConfirmHandler(config) {
+  const corsEnabled = config.cors !== false;
+  const corsConfig = config.cors === false ? void 0 : config.cors;
+  const respond = (data, status) => {
+    const response = import_server.NextResponse.json(data, { status });
+    return corsEnabled ? withCors(response, corsConfig) : response;
+  };
+  async function handler(request) {
+    if (request.method === "OPTIONS") {
+      const response = new import_server.NextResponse(null, { status: 204 });
+      return corsEnabled ? withCors(response, corsConfig) : response;
+    }
+    try {
+      const body = await request.json();
+      const { fileKey, size, contentType } = body;
+      if (!fileKey || typeof fileKey !== "string") {
+        return respond({ error: "fileKey is required" }, 400);
+      }
+      if (typeof size !== "number" || size <= 0) {
+        return respond({ error: "size must be a positive number" }, 400);
+      }
+      if (!contentType || typeof contentType !== "string") {
+        return respond({ error: "contentType is required" }, 400);
+      }
+      if (!isValidMimeType(contentType)) {
+        return respond({ error: "Invalid contentType format" }, 400);
+      }
+      const result = await config.stow.confirmUpload({
+        fileKey,
+        size,
+        contentType
+      });
+      await config.onUploadComplete?.(result);
+      return respond(result, 200);
+    } catch (error) {
+      console.error("Confirm error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return respond({ error: error.message }, status >= 400 ? status : 500);
+      }
+      return respond({ error: "Confirm failed" }, 500);
+    }
+  }
+  return handler;
+}
+function createUploadHandler(config) {
+  let warned = false;
+  return async function handler(request) {
+    if (!warned) {
+      console.warn(
+        "[@howells/stow-next] createUploadHandler is deprecated. Use createPresignHandler + createConfirmHandler for direct uploads. Proxied uploads are limited by serverless payload limits (~4.5MB on Vercel)."
+      );
+      warned = true;
+    }
+    try {
+      const formData = await request.formData();
+      const file = formData.get("file");
+      const route = formData.get("route") || config.route;
+      if (!file) {
+        return import_server.NextResponse.json(
+          { error: "No file provided" },
+          { status: 400 }
+        );
+      }
+      if (config.maxSize && file.size > config.maxSize) {
+        return import_server.NextResponse.json(
+          {
+            error: `File too large. Maximum size is ${formatBytes(config.maxSize)}`
+          },
+          { status: 400 }
+        );
+      }
+      if (config.allowedTypes && config.allowedTypes.length > 0) {
+        const isAllowed = config.allowedTypes.some((type) => {
+          if (type.endsWith("/*")) {
+            const prefix = type.slice(0, -1);
+            return file.type.startsWith(prefix);
+          }
+          return file.type === type;
+        });
+        if (!isAllowed) {
+          return import_server.NextResponse.json(
+            { error: `File type "${file.type}" is not allowed` },
+            { status: 400 }
+          );
+        }
+      }
+      if (config.validate) {
+        const validationResult = await config.validate(file);
+        if (validationResult !== true) {
+          return import_server.NextResponse.json(
+            {
+              error: typeof validationResult === "string" ? validationResult : "File validation failed"
+            },
+            { status: 400 }
+          );
+        }
+      }
+      await config.onUploadBegin?.(file);
+      const result = await config.stow.uploadFile(file, {
+        filename: file.name,
+        contentType: file.type,
+        route
+      });
+      await config.onUploadComplete?.(result);
+      return import_server.NextResponse.json(result);
+    } catch (error) {
+      console.error("Upload error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return import_server.NextResponse.json(
+          { error: error.message },
+          { status: status >= 400 ? status : 500 }
+        );
+      }
+      return import_server.NextResponse.json({ error: "Upload failed" }, { status: 500 });
+    }
+  };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+var MIME_TYPE_PATTERN = /^[a-z]+\/[a-z0-9.+-]+$/i;
+function isValidMimeType(mimeType) {
+  return MIME_TYPE_PATTERN.test(mimeType);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConfirmHandler,
+  createCorsPreflightHandler,
+  createPresignHandler,
+  createStowLoader,
+  createUploadHandler,
+  stowLoader
+});

package/dist/index.mjs

@@ -0,0 +1,267 @@
+import {
+  createStowLoader,
+  stowLoader
+} from "./chunk-WN3NWAEN.mjs";
+
+// src/index.ts
+import { NextResponse } from "next/server";
+var DEFAULT_CORS = {
+  origin: "*",
+  methods: ["POST", "OPTIONS"],
+  allowedHeaders: ["Content-Type"],
+  maxAge: 86400
+};
+function getLocalConfirmPath(pathname) {
+  if (pathname.endsWith("/presign")) {
+    const PRESIGN_SUFFIX_LENGTH = 7;
+    return `${pathname.slice(0, -PRESIGN_SUFFIX_LENGTH)}confirm`;
+  }
+  return pathname.endsWith("/") ? `${pathname}confirm` : `${pathname}/confirm`;
+}
+function withCors(response, config) {
+  const cors = { ...DEFAULT_CORS, ...config };
+  const origin = Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin;
+  response.headers.set("Access-Control-Allow-Origin", origin);
+  response.headers.set("Access-Control-Allow-Methods", cors.methods.join(", "));
+  response.headers.set(
+    "Access-Control-Allow-Headers",
+    cors.allowedHeaders.join(", ")
+  );
+  response.headers.set("Access-Control-Max-Age", cors.maxAge.toString());
+  return response;
+}
+function createCorsPreflightHandler(config) {
+  return function handler() {
+    return withCors(new NextResponse(null, { status: 204 }), config);
+  };
+}
+function createPresignHandler(config) {
+  const corsEnabled = config.cors !== false;
+  const corsConfig = config.cors === false ? void 0 : config.cors;
+  const respond = (data, status) => {
+    const response = NextResponse.json(data, { status });
+    return corsEnabled ? withCors(response, corsConfig) : response;
+  };
+  async function handler(request) {
+    if (request.method === "OPTIONS") {
+      const response = new NextResponse(null, { status: 204 });
+      return corsEnabled ? withCors(response, corsConfig) : response;
+    }
+    try {
+      const body = await request.json();
+      const { filename, contentType, size, route: requestRoute } = body;
+      if (!filename || typeof filename !== "string") {
+        return respond({ error: "filename is required" }, 400);
+      }
+      if (!contentType || typeof contentType !== "string") {
+        return respond({ error: "contentType is required" }, 400);
+      }
+      if (typeof size !== "number" || size <= 0) {
+        return respond({ error: "size must be a positive number" }, 400);
+      }
+      if (config.maxSize && size > config.maxSize) {
+        return respond(
+          {
+            error: `File too large. Maximum size is ${formatBytes(config.maxSize)}`
+          },
+          400
+        );
+      }
+      if (config.allowedTypes && config.allowedTypes.length > 0) {
+        const isAllowed = config.allowedTypes.some((type) => {
+          if (type.endsWith("/*")) {
+            const prefix = type.slice(0, -1);
+            return contentType.startsWith(prefix);
+          }
+          return contentType === type;
+        });
+        if (!isAllowed) {
+          return respond(
+            { error: `File type "${contentType}" is not allowed` },
+            400
+          );
+        }
+      }
+      if (config.validate) {
+        const validationResult = await config.validate({
+          filename,
+          contentType,
+          size
+        });
+        if (validationResult !== true) {
+          return respond(
+            {
+              error: typeof validationResult === "string" ? validationResult : "Validation failed"
+            },
+            400
+          );
+        }
+      }
+      const route = requestRoute || config.route;
+      const result = await config.stow.getPresignedUrl({
+        filename,
+        contentType,
+        size,
+        route
+      });
+      if ("dedupe" in result && result.dedupe) {
+        return respond(result, 200);
+      }
+      return respond(
+        {
+          ...result,
+          confirmUrl: getLocalConfirmPath(request.nextUrl.pathname)
+        },
+        200
+      );
+    } catch (error) {
+      console.error("Presign error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return respond({ error: error.message }, status >= 400 ? status : 500);
+      }
+      return respond({ error: "Presign failed" }, 500);
+    }
+  }
+  return handler;
+}
+function createConfirmHandler(config) {
+  const corsEnabled = config.cors !== false;
+  const corsConfig = config.cors === false ? void 0 : config.cors;
+  const respond = (data, status) => {
+    const response = NextResponse.json(data, { status });
+    return corsEnabled ? withCors(response, corsConfig) : response;
+  };
+  async function handler(request) {
+    if (request.method === "OPTIONS") {
+      const response = new NextResponse(null, { status: 204 });
+      return corsEnabled ? withCors(response, corsConfig) : response;
+    }
+    try {
+      const body = await request.json();
+      const { fileKey, size, contentType } = body;
+      if (!fileKey || typeof fileKey !== "string") {
+        return respond({ error: "fileKey is required" }, 400);
+      }
+      if (typeof size !== "number" || size <= 0) {
+        return respond({ error: "size must be a positive number" }, 400);
+      }
+      if (!contentType || typeof contentType !== "string") {
+        return respond({ error: "contentType is required" }, 400);
+      }
+      if (!isValidMimeType(contentType)) {
+        return respond({ error: "Invalid contentType format" }, 400);
+      }
+      const result = await config.stow.confirmUpload({
+        fileKey,
+        size,
+        contentType
+      });
+      await config.onUploadComplete?.(result);
+      return respond(result, 200);
+    } catch (error) {
+      console.error("Confirm error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return respond({ error: error.message }, status >= 400 ? status : 500);
+      }
+      return respond({ error: "Confirm failed" }, 500);
+    }
+  }
+  return handler;
+}
+function createUploadHandler(config) {
+  let warned = false;
+  return async function handler(request) {
+    if (!warned) {
+      console.warn(
+        "[@howells/stow-next] createUploadHandler is deprecated. Use createPresignHandler + createConfirmHandler for direct uploads. Proxied uploads are limited by serverless payload limits (~4.5MB on Vercel)."
+      );
+      warned = true;
+    }
+    try {
+      const formData = await request.formData();
+      const file = formData.get("file");
+      const route = formData.get("route") || config.route;
+      if (!file) {
+        return NextResponse.json(
+          { error: "No file provided" },
+          { status: 400 }
+        );
+      }
+      if (config.maxSize && file.size > config.maxSize) {
+        return NextResponse.json(
+          {
+            error: `File too large. Maximum size is ${formatBytes(config.maxSize)}`
+          },
+          { status: 400 }
+        );
+      }
+      if (config.allowedTypes && config.allowedTypes.length > 0) {
+        const isAllowed = config.allowedTypes.some((type) => {
+          if (type.endsWith("/*")) {
+            const prefix = type.slice(0, -1);
+            return file.type.startsWith(prefix);
+          }
+          return file.type === type;
+        });
+        if (!isAllowed) {
+          return NextResponse.json(
+            { error: `File type "${file.type}" is not allowed` },
+            { status: 400 }
+          );
+        }
+      }
+      if (config.validate) {
+        const validationResult = await config.validate(file);
+        if (validationResult !== true) {
+          return NextResponse.json(
+            {
+              error: typeof validationResult === "string" ? validationResult : "File validation failed"
+            },
+            { status: 400 }
+          );
+        }
+      }
+      await config.onUploadBegin?.(file);
+      const result = await config.stow.uploadFile(file, {
+        filename: file.name,
+        contentType: file.type,
+        route
+      });
+      await config.onUploadComplete?.(result);
+      return NextResponse.json(result);
+    } catch (error) {
+      console.error("Upload error:", error);
+      if (error instanceof Error && "status" in error && typeof error.status === "number") {
+        const status = error.status;
+        return NextResponse.json(
+          { error: error.message },
+          { status: status >= 400 ? status : 500 }
+        );
+      }
+      return NextResponse.json({ error: "Upload failed" }, { status: 500 });
+    }
+  };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+var MIME_TYPE_PATTERN = /^[a-z]+\/[a-z0-9.+-]+$/i;
+function isValidMimeType(mimeType) {
+  return MIME_TYPE_PATTERN.test(mimeType);
+}
+export {
+  createConfirmHandler,
+  createCorsPreflightHandler,
+  createPresignHandler,
+  createStowLoader,
+  createUploadHandler,
+  stowLoader
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@howells/stow-next",
+  "version": "0.1.0",
+  "description": "Next.js integration for Stow file storage",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/howells/stow.git",
+    "directory": "packages/stow-next"
+  },
+  "homepage": "https://stow.sh",
+  "keywords": [
+    "stow",
+    "file-storage",
+    "nextjs",
+    "image-loader",
+    "sdk"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./image-loader": {
+      "types": "./dist/image-loader.d.ts",
+      "import": "./dist/image-loader.mjs",
+      "require": "./dist/image-loader.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/image-loader.ts --format cjs,esm --dts --external next --external react",
+    "dev": "tsup src/index.ts src/image-loader.ts --format cjs,esm --dts --external next --external react --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "next": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@stow/typescript-config": "workspace:*",
+    "@types/react": "19.2.14",
+    "next": "16.1.6",
+    "react": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}