feat(image-processing-api): add relative url support

Author: cabljac

extensions/image-processing-api/functions/src/index.ts

@@ -40,6 +40,7 @@ import sharp from 'sharp';
 async function processImageRequest(
   validatedOperations: ValidatedOperation[],
   res: Response,
+  req: Request,
 ): Promise<void> {
   const firstOperation = validatedOperations[0];
   const lastOperation = validatedOperations[validatedOperations.length - 1];
@@ -62,7 +63,7 @@ async function processImageRequest(
   let instance: sharp.Sharp | null = null;
   for (let i = 0; i < validatedOperations.length; i++) {
     const validatedOperation = validatedOperations[i];
-    instance = await applyValidatedOperation(instance, validatedOperation);
+    instance = await applyValidatedOperation(instance, validatedOperation, req);
   }
 
   const finalFileMetadata = omitKeys(
@@ -142,7 +143,7 @@ app.get(
     const validatedOperations: ValidatedOperation[] =
       jsonAsValidatedOperations(operations);
     const [processError] = await a2a(
-      processImageRequest(validatedOperations, res),
+      processImageRequest(validatedOperations, res, req),
     );
     if (processError) {
       return next(processError);
@@ -160,7 +161,7 @@ app.get(
     const validatedOperations: ValidatedOperation[] =
       asValidatedOperations(operationsString);
     const [processError] = await a2a(
-      processImageRequest(validatedOperations, res),
+      processImageRequest(validatedOperations, res, req),
     );
     if (processError) {
       return next(processError);

extensions/image-processing-api/functions/src/operations/index.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import express from 'express';
 import { AssertionError } from 'assert';
 import sharp, { SharpOptions } from 'sharp';
 import superstruct from 'superstruct';
@@ -232,10 +233,11 @@ export function asValidatedOperations(input: string): ValidatedOperation[] {
 export async function asBuiltOperation(
   validatedOperation: ValidatedOperation,
   fileMetadata: sharp.Metadata | null,
+  req?: express.Request,
 ): Promise<BuiltOperation> {
   const actionBuilder =
     builderForOperation(validatedOperation)?.build || defaultActionsBuilder;
-  let builtActions = actionBuilder(validatedOperation, fileMetadata);
+  let builtActions = actionBuilder(validatedOperation, fileMetadata, req);
   if (builtActions instanceof Promise) {
     builtActions = await builtActions;
   }
@@ -248,6 +250,7 @@ export async function asBuiltOperation(
 export async function applyValidatedOperation(
   instance: sharp.Sharp | null,
   validatedOperation: ValidatedOperation,
+  req?: express.Request,
 ): Promise<sharp.Sharp> {
   let currentInstance = instance;
   const currentMetadata = currentInstance
@@ -256,6 +259,7 @@ export async function applyValidatedOperation(
   const builtOperation = await asBuiltOperation(
     validatedOperation,
     currentMetadata,
+    req,
   );
   for (let i = 0; i < builtOperation.actions.length; i++) {
     const action = builtOperation.actions[i];

extensions/image-processing-api/functions/src/operations/input.ts

@@ -15,6 +15,7 @@
  */
 
 import * as superstruct from 'superstruct';
+import express from 'express';
 
 import * as utils from '../utils';
 import { Operation, OperationAction, OperationBuilder } from '../types';
@@ -48,6 +49,15 @@ const structFromUrl = superstruct.object({
   url: superstruct.string(),
 });
 
+/**
+ * A path url of an image. The request hostname will be prepended to this path.
+ */
+const structFromPath = superstruct.object({
+  operation: superstruct.literal(name),
+  type: superstruct.literal('path'),
+  path: superstruct.string(),
+});
+
 /**
  * Create a new image.
  */
@@ -110,18 +120,21 @@ const structCreateNewImage = superstruct.object({
 const struct = superstruct.union([
   structFromGcs,
   structFromUrl,
+  structFromPath,
   structCreateNewImage,
 ]);
 
 export type OperationInputGcs = superstruct.Infer<typeof structFromGcs>;
 export type OperationInputUrl = superstruct.Infer<typeof structFromUrl>;
+export type OperationInputPath = superstruct.Infer<typeof structFromPath>;
 export type OperationInputCreateNew = superstruct.Infer<
   typeof structCreateNewImage
 >;
 
 export type OperationInput =
   | OperationInputGcs
   | OperationInputUrl
+  | OperationInputPath
   | OperationInputCreateNew;
 
 export const operationInput: OperationBuilder = {
@@ -135,12 +148,14 @@ export const operationInput: OperationBuilder = {
         return structFromGcs.create(rawOptions);
       case 'url':
         return structFromUrl.create(rawOptions);
+      case 'path':
+        return structFromPath.create(rawOptions);
     }
     throw new AssertionError({
       message: `'${rawOptions.type}' is not a valid input 'type'.`,
     });
   },
-  async build(operation) {
+  async build(operation, _fileMetadata, req) {
     const options = operation.options as OperationInput;
 
     switch (options.type) {
@@ -150,6 +165,8 @@ export const operationInput: OperationBuilder = {
         return await fetchGcsFile(options);
       case 'url':
         return await fetchUrl(options);
+      case 'path':
+        return await fetchPathUrl(options, req);
     }
   },
 };
@@ -169,6 +186,57 @@ async function fetchUrl(options: OperationInput): Promise<OperationAction[]> {
   ];
 }
 
+async function fetchPathUrl(
+  options: OperationInput,
+  req?: express.Request,
+): Promise<OperationAction[]> {
+  if (options.type !== 'path') return [];
+
+  if (!req) {
+    throw new AssertionError({
+      message: 'Request object is required for path type inputs.',
+    });
+  }
+
+  // Extract hostname from request
+  const origin = (req.headers.origin as string) || '';
+  const referer = (req.headers.referer as string) || '';
+  const host = req.headers.host || '';
+
+  let baseUrl = '';
+
+  // Try to get the base URL from various sources
+  if (origin) {
+    baseUrl = origin;
+  } else if (referer) {
+    try {
+      const url = new URL(referer);
+      baseUrl = `${url.protocol}//${url.host}`;
+    } catch (e) {
+      // Invalid URL format in referer
+    }
+  } else if (host) {
+    const protocol = req.secure ? 'https:' : 'http:';
+    baseUrl = `${protocol}//${host}`;
+  }
+
+  if (!baseUrl) {
+    throw new AssertionError({
+      message: `Could not determine request hostname for path URL.`,
+    });
+  }
+
+  // Construct the full URL
+  const fullUrl = `${baseUrl}${options.path}`;
+
+  return [
+    {
+      method: 'constructor',
+      arguments: [await fetchImageBufferFromUrl(fullUrl)],
+    },
+  ];
+}
+
 async function fetchGcsFile(
   options: OperationInput,
 ): Promise<OperationAction[]> {

extensions/image-processing-api/functions/src/types.ts

@@ -15,10 +15,12 @@
  */
 import * as superstruct from 'superstruct';
 import sharp from 'sharp';
+import express from 'express';
 
 export type ActionBuilder = (
   validatedOperation: ValidatedOperation,
   imageMetadata: sharp.Metadata | null,
+  req?: express.Request,
 ) => OperationAction[] | Promise<OperationAction[]>;
 
 export type OperationBuilder = {