Merge pull request #948 from constructive-io/devin/1775032006-wire-presigned-url-preset

feat: wire PresignedUrlPreset into ConstructivePreset (Step 2g)

Author: pyramation

graphile/graphile-presigned-url-plugin/src/download-url-field.ts

@@ -16,7 +16,7 @@
 import type { GraphileConfig } from 'graphile-config';
 import { Logger } from '@pgpmjs/logger';
 
-import type { PresignedUrlPluginOptions } from './types';
+import type { PresignedUrlPluginOptions, S3Config } from './types';
 import { generatePresignedGetUrl } from './s3-signer';
 import { getStorageModuleConfig } from './storage-module-cache';
 
@@ -31,10 +31,22 @@ const log = new Logger('graphile-presigned-url:download-url');
  * the storage module's files table, which we discover at schema-build time
  * via the `@storageFiles` smart tag.
  */
+/**
+ * Resolve the S3 config from the options. If the option is a lazy getter
+ * function, call it (and cache the result).
+ */
+function resolveS3(options: PresignedUrlPluginOptions): S3Config {
+  if (typeof options.s3 === 'function') {
+    const resolved = options.s3();
+    options.s3 = resolved;
+    return resolved;
+  }
+  return options.s3;
+}
+
 export function createDownloadUrlPlugin(
   options: PresignedUrlPluginOptions,
 ): GraphileConfig.Plugin {
-  const { s3 } = options;
 
   return {
     name: 'PresignedUrlDownloadPlugin',
@@ -88,6 +100,8 @@ export function createDownloadUrlPlugin(
                       return null;
                     }
 
+                    const s3 = resolveS3(options);
+
                     if (isPublic && s3.publicUrlPrefix) {
                       // Public file: return direct URL
                       return `${s3.publicUrlPrefix}/${key}`;
@@ -118,7 +132,7 @@ export function createDownloadUrlPlugin(
 
                     // Private file: generate presigned GET URL
                     return generatePresignedGetUrl(
-                      s3,
+                      resolveS3(options),
                       key,
                       downloadUrlExpirySeconds,
                       filename || undefined,

graphile/graphile-presigned-url-plugin/src/index.ts

@@ -40,5 +40,6 @@ export type {
   ConfirmUploadInput,
   ConfirmUploadPayload,
   S3Config,
+  S3ConfigOrGetter,
   PresignedUrlPluginOptions,
 } from './types';

graphile/graphile-presigned-url-plugin/src/plugin.ts

@@ -22,7 +22,7 @@ import type { GraphileConfig } from 'graphile-config';
 import { extendSchema, gql } from 'graphile-utils';
 import { Logger } from '@pgpmjs/logger';
 
-import type { PresignedUrlPluginOptions } from './types';
+import type { PresignedUrlPluginOptions, S3Config } from './types';
 import { getStorageModuleConfig, getBucketConfig } from './storage-module-cache';
 import { generatePresignedPutUrl, headObject } from './s3-signer';
 
@@ -67,10 +67,24 @@ async function resolveDatabaseId(pgClient: any): Promise<string | null> {
 
 // --- Plugin factory ---
 
+/**
+ * Resolve the S3 config from the options. If the option is a lazy getter
+ * function, call it (and cache the result). This avoids reading env vars
+ * or constructing an S3Client at module-import time.
+ */
+function resolveS3(options: PresignedUrlPluginOptions): S3Config {
+  if (typeof options.s3 === 'function') {
+    const resolved = options.s3();
+    // Cache so subsequent calls don't re-evaluate
+    options.s3 = resolved;
+    return resolved;
+  }
+  return options.s3;
+}
+
 export function createPresignedUrlPlugin(
   options: PresignedUrlPluginOptions,
 ): GraphileConfig.Plugin {
-  const { s3 } = options;
 
   return extendSchema(() => ({
     typeDefs: gql`
@@ -272,7 +286,7 @@ export function createPresignedUrlPlugin(
 
                 // --- Generate presigned PUT URL ---
                 const uploadUrl = await generatePresignedPutUrl(
-                  s3,
+                  resolveS3(options),
                   s3Key,
                   contentType,
                   size,
@@ -362,7 +376,7 @@ export function createPresignedUrlPlugin(
                 }
 
                 // --- Verify file exists in S3 ---
-                const s3Head = await headObject(s3, file.key, file.content_type);
+                const s3Head = await headObject(resolveS3(options), file.key, file.content_type);
 
                 if (!s3Head) {
                   throw new Error('FILE_NOT_IN_S3: the file has not been uploaded yet');

graphile/graphile-presigned-url-plugin/src/storage-module-cache.ts

@@ -44,6 +44,9 @@ const STORAGE_MODULE_QUERY = `
     ft.name AS files_table,
     urs.schema_name AS upload_requests_schema,
     urt.name AS upload_requests_table,
+    sm.endpoint,
+    sm.public_url_prefix,
+    sm.provider,
     sm.upload_url_expiry_seconds,
     sm.download_url_expiry_seconds,
     sm.default_max_file_size,
@@ -68,6 +71,9 @@ interface StorageModuleRow {
   files_table: string;
   upload_requests_schema: string;
   upload_requests_table: string;
+  endpoint: string | null;
+  public_url_prefix: string | null;
+  provider: string | null;
   upload_url_expiry_seconds: number | null;
   download_url_expiry_seconds: number | null;
   default_max_file_size: number | null;
@@ -112,6 +118,9 @@ export async function getStorageModuleConfig(
     bucketsTableName: row.buckets_table,
     filesTableName: row.files_table,
     uploadRequestsTableName: row.upload_requests_table,
+    endpoint: row.endpoint,
+    publicUrlPrefix: row.public_url_prefix,
+    provider: row.provider,
     uploadUrlExpirySeconds: row.upload_url_expiry_seconds ?? DEFAULT_UPLOAD_URL_EXPIRY_SECONDS,
     downloadUrlExpirySeconds: row.download_url_expiry_seconds ?? DEFAULT_DOWNLOAD_URL_EXPIRY_SECONDS,
     defaultMaxFileSize: row.default_max_file_size ?? DEFAULT_MAX_FILE_SIZE,

graphile/graphile-presigned-url-plugin/src/types.ts

@@ -34,6 +34,15 @@ export interface StorageModuleConfig {
   /** Upload requests table name */
   uploadRequestsTableName: string;
 
+  // --- S3 connection config (NULL in DB = use global env/plugin defaults) ---
+
+  /** S3-compatible API endpoint URL (per-database override) */
+  endpoint: string | null;
+  /** Public URL prefix for generating download URLs (per-database override) */
+  publicUrlPrefix: string | null;
+  /** Storage provider type: 'minio', 's3', 'gcs', etc. (per-database override) */
+  provider: string | null;
+
   // --- Per-database configurable settings ---
 
   /** Presigned PUT URL expiry in seconds (default: 900 = 15 min) */
@@ -118,10 +127,18 @@ export interface S3Config {
   publicUrlPrefix?: string;
 }
 
+/**
+ * S3 configuration or a lazy getter that returns it on first use.
+ * When a function is provided, it will only be called when the first
+ * mutation or resolver actually needs the S3 client — avoiding eager
+ * env-var reads and S3Client creation at module import time.
+ */
+export type S3ConfigOrGetter = S3Config | (() => S3Config);
+
 /**
  * Plugin options for the presigned URL plugin.
  */
 export interface PresignedUrlPluginOptions {
-  /** S3 configuration */
-  s3: S3Config;
+  /** S3 configuration (concrete or lazy getter) */
+  s3: S3ConfigOrGetter;
 }

graphile/graphile-settings/__tests__/upload-resolver.test.ts

@@ -35,7 +35,7 @@ async function loadUploadResolverModule(opts: {
         awsRegion: 'us-east-1',
         awsAccessKey: 'test',
         awsSecretKey: 'test',
-        minioEndpoint: 'http://localhost:9000',
+        endpoint: 'http://localhost:9000',
       },
     })),
   }));

graphile/graphile-settings/package.json

@@ -29,6 +29,7 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1009.0",
     "@constructive-io/graphql-env": "workspace:^",
     "@constructive-io/graphql-types": "workspace:^",
     "@constructive-io/s3-streamer": "workspace:^",
@@ -48,6 +49,7 @@
     "graphile-config": "1.0.0",
     "graphile-connection-filter": "workspace:^",
     "graphile-postgis": "workspace:^",
+    "graphile-presigned-url-plugin": "workspace:^",
     "graphile-search": "workspace:^",
     "graphile-sql-expression-validator": "workspace:^",
     "graphile-upload-plugin": "workspace:^",

graphile/graphile-settings/src/index.ts

@@ -59,3 +59,6 @@ export { makePgService };
 
 // Upload utilities
 export { streamToStorage } from './upload-resolver';
+
+// Presigned URL utilities
+export { getPresignedUrlS3Config } from './presigned-url-resolver';

graphile/graphile-settings/src/presets/constructive-preset.ts

@@ -15,8 +15,10 @@ import {
 import { UnifiedSearchPreset, createMatchesOperatorFactory, createTrgmOperatorFactories } from 'graphile-search';
 import { GraphilePostgisPreset, createPostgisOperatorFactory } from 'graphile-postgis';
 import { UploadPreset } from 'graphile-upload-plugin';
+import { PresignedUrlPreset } from 'graphile-presigned-url-plugin';
 import { SqlExpressionValidatorPreset } from 'graphile-sql-expression-validator';
 import { constructiveUploadFieldDefinitions } from '../upload-resolver';
+import { getPresignedUrlS3Config } from '../presigned-url-resolver';
 
 /**
  * Constructive PostGraphile v5 Preset
@@ -36,6 +38,7 @@ import { constructiveUploadFieldDefinitions } from '../upload-resolver';
  * - PostGIS support (geometry/geography types, GeoJSON scalar — auto-detects PostGIS extension)
  * - PostGIS connection filter operators (spatial filtering on geometry/geography columns)
  * - Upload plugin (file upload to S3/MinIO for image, upload, attachment domain columns)
+ * - Presigned URL plugin (requestUploadUrl, confirmUpload mutations + downloadUrl computed field)
  * - SQL expression validator (validates @sqlExpression columns in mutations)
  * - PG type mappings (maps custom types like email, url to GraphQL scalars)
  * - pgvector search (auto-discovers vector columns: filter fields, distance computed fields,
@@ -83,6 +86,7 @@ export const ConstructivePreset: GraphileConfig.Preset = {
       uploadFieldDefinitions: constructiveUploadFieldDefinitions,
       maxFileSize: 10 * 1024 * 1024, // 10MB
     }),
+    PresignedUrlPreset({ s3: getPresignedUrlS3Config }),
     SqlExpressionValidatorPreset(),
     PgTypeMappingsPreset,
     RequiredInputPreset,

graphile/graphile-settings/src/presigned-url-resolver.ts

@@ -0,0 +1,54 @@
+/**
+ * Presigned URL resolver for the Constructive presigned URL plugin.
+ *
+ * Reads CDN/S3 configuration from the standard env system
+ * (getEnvOptions → pgpmDefaults + config files + env vars) and lazily
+ * initializes an S3Client on first use.
+ *
+ * Follows the same lazy-init pattern as upload-resolver.ts.
+ */
+
+import { S3Client } from '@aws-sdk/client-s3';
+import { getEnvOptions } from '@constructive-io/graphql-env';
+import { Logger } from '@pgpmjs/logger';
+import type { S3Config } from 'graphile-presigned-url-plugin';
+
+const log = new Logger('presigned-url-resolver');
+
+let s3Config: S3Config | null = null;
+
+/**
+ * Lazily initialize and return the S3Config for the presigned URL plugin.
+ *
+ * Reads CDN config on first call via getEnvOptions() (which already merges
+ * pgpmDefaults → config file → env vars), creates an S3Client, and caches
+ * the result. Same CDN config as upload-resolver.ts.
+ */
+export function getPresignedUrlS3Config(): S3Config {
+  if (s3Config) return s3Config;
+
+  const { cdn } = getEnvOptions();
+
+  // cdn is guaranteed populated — pgpmDefaults provides all CDN fields
+  const { bucketName, awsRegion, awsAccessKey, awsSecretKey, endpoint, publicUrlPrefix } = cdn!;
+
+  log.info(
+    `[presigned-url-resolver] Initializing: bucket=${bucketName} endpoint=${endpoint}`,
+  );
+
+  const client = new S3Client({
+    region: awsRegion,
+    credentials: { accessKeyId: awsAccessKey!, secretAccessKey: awsSecretKey! },
+    ...(endpoint ? { endpoint, forcePathStyle: true } : {}),
+  });
+
+  s3Config = {
+    client,
+    bucket: bucketName!,
+    region: awsRegion,
+    publicUrlPrefix,
+    ...(endpoint ? { endpoint, forcePathStyle: true } : {}),
+  };
+
+  return s3Config;
+}