graphile-presigned-url-plugin 0.11.0 → 0.12.0

package/esm/plugin.d.ts

@@ -9,11 +9,14 @@
  * 2. Upload fields — adds `requestUploadUrl` and `requestBulkUploadUrls` fields
  *    on `@storageBuckets`-tagged types, so clients upload via the typed bucket API.
  *
- * 3. downloadUrl — handled by download-url-field.ts (separate plugin).
+ * 3. Mutation entry points — adds per-bucket mutation fields on the root Mutation
+ *    type (e.g., `appBucket(key: "public"): AppBucket`), so upload operations
+ *    can be accessed as proper GraphQL mutations instead of queries.
  *
- * No global mutations — all S3 operations are scoped to the per-table types that
- * PostGraphile already generates. Scope resolution uses the codec's schema/table
- * name matched against cached storage module configs.
+ * 4. downloadUrl — handled by download-url-field.ts (separate plugin).
+ *
+ * Scope resolution uses the codec's schema/table name matched against
+ * cached storage module configs.
  */
 import type { GraphileConfig } from 'graphile-config';
 import 'graphile-build';

package/esm/plugin.js

@@ -9,16 +9,19 @@
  * 2. Upload fields — adds `requestUploadUrl` and `requestBulkUploadUrls` fields
  *    on `@storageBuckets`-tagged types, so clients upload via the typed bucket API.
  *
- * 3. downloadUrl — handled by download-url-field.ts (separate plugin).
+ * 3. Mutation entry points — adds per-bucket mutation fields on the root Mutation
+ *    type (e.g., `appBucket(key: "public"): AppBucket`), so upload operations
+ *    can be accessed as proper GraphQL mutations instead of queries.
  *
- * No global mutations — all S3 operations are scoped to the per-table types that
- * PostGraphile already generates. Scope resolution uses the codec's schema/table
- * name matched against cached storage module configs.
+ * 4. downloadUrl — handled by download-url-field.ts (separate plugin).
+ *
+ * Scope resolution uses the codec's schema/table name matched against
+ * cached storage module configs.
  */
-import { context as grafastContext, lambda, object } from 'grafast';
+import { access, context as grafastContext, lambda, object } from 'grafast';
 import 'graphile-build';
 import { Logger } from '@pgpmjs/logger';
-import { loadAllStorageModules, resolveStorageConfigFromCodec, isS3BucketProvisioned, markS3BucketProvisioned } from './storage-module-cache';
+import { loadAllStorageModules, resolveStorageConfigFromCodec, getBucketConfig, isS3BucketProvisioned, markS3BucketProvisioned } from './storage-module-cache';
 import { generatePresignedPutUrl, deleteS3Object } from './s3-signer';
 const log = new Logger('graphile-presigned-url:plugin');
 // --- Protocol-level constants (not configurable) ---
@@ -111,7 +114,71 @@ export function createPresignedUrlPlugin(options) {
                  * Add requestUploadUrl and requestBulkUploadUrls fields on @storageBuckets types.
                  */
                 GraphQLObjectType_fields(fields, build, context) {
-                    const { scope: { pgCodec, isPgClassType }, } = context;
+                    const { scope: { pgCodec, isPgClassType, isRootMutation }, } = context;
+                    // --- Path 1: Add per-bucket mutation entry points on root Mutation ---
+                    if (isRootMutation) {
+                        const { graphql: { GraphQLString, GraphQLNonNull }, } = build;
+                        const bucketCodecs = Object.values(build.input.pgRegistry.pgCodecs).filter((codec) => codec.attributes && codec.extensions?.tags?.storageBuckets);
+                        if (bucketCodecs.length === 0)
+                            return fields;
+                        const newFields = {};
+                        for (const codec of bucketCodecs) {
+                            const typeName = build.inflection.tableType(codec);
+                            const bucketType = build.getTypeByName(typeName);
+                            if (!bucketType) {
+                                log.debug(`Skipping mutation entry point for ${codec.name}: type ${typeName} not found`);
+                                continue;
+                            }
+                            const fieldName = typeName.charAt(0).toLowerCase() + typeName.slice(1);
+                            const hasOwnerId = !!codec.attributes.owner_id;
+                            const capturedCodec = codec;
+                            log.debug(`Adding mutation entry point "${fieldName}" for bucket type ${typeName} (entity-scoped=${hasOwnerId})`);
+                            newFields[fieldName] = context.fieldWithHooks({ fieldName }, {
+                                description: `Look up a ${typeName} by key for mutation operations (upload, etc.).`,
+                                type: bucketType,
+                                args: {
+                                    key: { type: new GraphQLNonNull(GraphQLString), description: 'Bucket key (e.g., "public", "private")' },
+                                    ...(hasOwnerId
+                                        ? { ownerId: { type: new GraphQLNonNull(GraphQLString), description: 'Owner entity ID (required for entity-scoped buckets)' } }
+                                        : {}),
+                                },
+                                plan(_$mutation, fieldArgs) {
+                                    const $key = fieldArgs.getRaw('key');
+                                    const $ownerId = hasOwnerId ? fieldArgs.getRaw('ownerId') : lambda(null, () => null);
+                                    const $withPgClient = grafastContext().get('withPgClient');
+                                    const $pgSettings = grafastContext().get('pgSettings');
+                                    const $combined = object({
+                                        key: $key,
+                                        ownerId: $ownerId,
+                                        withPgClient: $withPgClient,
+                                        pgSettings: $pgSettings,
+                                    });
+                                    const $row = lambda($combined, async (vals) => {
+                                        return vals.withPgClient(vals.pgSettings, async (pgClient) => {
+                                            const databaseId = await resolveDatabaseId(pgClient);
+                                            if (!databaseId)
+                                                throw new Error('DATABASE_NOT_FOUND');
+                                            const allConfigs = await loadAllStorageModules(pgClient, databaseId);
+                                            const storageConfig = resolveStorageConfigFromCodec(capturedCodec, allConfigs);
+                                            if (!storageConfig)
+                                                throw new Error('STORAGE_MODULE_NOT_FOUND');
+                                            const bucket = await getBucketConfig(pgClient, storageConfig, databaseId, vals.key, vals.ownerId ?? undefined);
+                                            if (!bucket)
+                                                throw new Error('BUCKET_NOT_FOUND');
+                                            return bucket;
+                                        });
+                                    });
+                                    const columnEntries = {};
+                                    for (const col of Object.keys(capturedCodec.attributes)) {
+                                        columnEntries[col] = access($row, col);
+                                    }
+                                    return object(columnEntries);
+                                },
+                            });
+                        }
+                        return build.extend(fields, newFields, 'PresignedUrlPlugin adding per-bucket mutation entry points');
+                    }
+                    // --- Path 2: Add upload fields on @storageBuckets types ---
                     if (!isPgClassType || !pgCodec || !pgCodec.attributes) {
                         return fields;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-presigned-url-plugin",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Presigned URL upload plugin for PostGraphile v5 — requestUploadUrl mutation and downloadUrl computed field",
   "author": "Constructive <developers@constructive.io>",
   "homepage": "https://github.com/constructive-io/constructive",
@@ -60,5 +60,5 @@
     "@types/node": "^22.19.11",
     "makage": "^0.1.10"
   },
-  "gitHead": "7409479a981ff63a0937b5406a1c206a07b264ad"
+  "gitHead": "31a008c2064e5fea05ae178a7b4e2ecbc1beb6cb"
 }

package/plugin.d.ts

@@ -9,11 +9,14 @@
  * 2. Upload fields — adds `requestUploadUrl` and `requestBulkUploadUrls` fields
  *    on `@storageBuckets`-tagged types, so clients upload via the typed bucket API.
  *
- * 3. downloadUrl — handled by download-url-field.ts (separate plugin).
+ * 3. Mutation entry points — adds per-bucket mutation fields on the root Mutation
+ *    type (e.g., `appBucket(key: "public"): AppBucket`), so upload operations
+ *    can be accessed as proper GraphQL mutations instead of queries.
  *
- * No global mutations — all S3 operations are scoped to the per-table types that
- * PostGraphile already generates. Scope resolution uses the codec's schema/table
- * name matched against cached storage module configs.
+ * 4. downloadUrl — handled by download-url-field.ts (separate plugin).
+ *
+ * Scope resolution uses the codec's schema/table name matched against
+ * cached storage module configs.
  */
 import type { GraphileConfig } from 'graphile-config';
 import 'graphile-build';

package/plugin.js

@@ -10,11 +10,14 @@
  * 2. Upload fields — adds `requestUploadUrl` and `requestBulkUploadUrls` fields
  *    on `@storageBuckets`-tagged types, so clients upload via the typed bucket API.
  *
- * 3. downloadUrl — handled by download-url-field.ts (separate plugin).
+ * 3. Mutation entry points — adds per-bucket mutation fields on the root Mutation
+ *    type (e.g., `appBucket(key: "public"): AppBucket`), so upload operations
+ *    can be accessed as proper GraphQL mutations instead of queries.
  *
- * No global mutations — all S3 operations are scoped to the per-table types that
- * PostGraphile already generates. Scope resolution uses the codec's schema/table
- * name matched against cached storage module configs.
+ * 4. downloadUrl — handled by download-url-field.ts (separate plugin).
+ *
+ * Scope resolution uses the codec's schema/table name matched against
+ * cached storage module configs.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresignedUrlPlugin = void 0;
@@ -115,7 +118,71 @@ function createPresignedUrlPlugin(options) {
                  * Add requestUploadUrl and requestBulkUploadUrls fields on @storageBuckets types.
                  */
                 GraphQLObjectType_fields(fields, build, context) {
-                    const { scope: { pgCodec, isPgClassType }, } = context;
+                    const { scope: { pgCodec, isPgClassType, isRootMutation }, } = context;
+                    // --- Path 1: Add per-bucket mutation entry points on root Mutation ---
+                    if (isRootMutation) {
+                        const { graphql: { GraphQLString, GraphQLNonNull }, } = build;
+                        const bucketCodecs = Object.values(build.input.pgRegistry.pgCodecs).filter((codec) => codec.attributes && codec.extensions?.tags?.storageBuckets);
+                        if (bucketCodecs.length === 0)
+                            return fields;
+                        const newFields = {};
+                        for (const codec of bucketCodecs) {
+                            const typeName = build.inflection.tableType(codec);
+                            const bucketType = build.getTypeByName(typeName);
+                            if (!bucketType) {
+                                log.debug(`Skipping mutation entry point for ${codec.name}: type ${typeName} not found`);
+                                continue;
+                            }
+                            const fieldName = typeName.charAt(0).toLowerCase() + typeName.slice(1);
+                            const hasOwnerId = !!codec.attributes.owner_id;
+                            const capturedCodec = codec;
+                            log.debug(`Adding mutation entry point "${fieldName}" for bucket type ${typeName} (entity-scoped=${hasOwnerId})`);
+                            newFields[fieldName] = context.fieldWithHooks({ fieldName }, {
+                                description: `Look up a ${typeName} by key for mutation operations (upload, etc.).`,
+                                type: bucketType,
+                                args: {
+                                    key: { type: new GraphQLNonNull(GraphQLString), description: 'Bucket key (e.g., "public", "private")' },
+                                    ...(hasOwnerId
+                                        ? { ownerId: { type: new GraphQLNonNull(GraphQLString), description: 'Owner entity ID (required for entity-scoped buckets)' } }
+                                        : {}),
+                                },
+                                plan(_$mutation, fieldArgs) {
+                                    const $key = fieldArgs.getRaw('key');
+                                    const $ownerId = hasOwnerId ? fieldArgs.getRaw('ownerId') : (0, grafast_1.lambda)(null, () => null);
+                                    const $withPgClient = (0, grafast_1.context)().get('withPgClient');
+                                    const $pgSettings = (0, grafast_1.context)().get('pgSettings');
+                                    const $combined = (0, grafast_1.object)({
+                                        key: $key,
+                                        ownerId: $ownerId,
+                                        withPgClient: $withPgClient,
+                                        pgSettings: $pgSettings,
+                                    });
+                                    const $row = (0, grafast_1.lambda)($combined, async (vals) => {
+                                        return vals.withPgClient(vals.pgSettings, async (pgClient) => {
+                                            const databaseId = await resolveDatabaseId(pgClient);
+                                            if (!databaseId)
+                                                throw new Error('DATABASE_NOT_FOUND');
+                                            const allConfigs = await (0, storage_module_cache_1.loadAllStorageModules)(pgClient, databaseId);
+                                            const storageConfig = (0, storage_module_cache_1.resolveStorageConfigFromCodec)(capturedCodec, allConfigs);
+                                            if (!storageConfig)
+                                                throw new Error('STORAGE_MODULE_NOT_FOUND');
+                                            const bucket = await (0, storage_module_cache_1.getBucketConfig)(pgClient, storageConfig, databaseId, vals.key, vals.ownerId ?? undefined);
+                                            if (!bucket)
+                                                throw new Error('BUCKET_NOT_FOUND');
+                                            return bucket;
+                                        });
+                                    });
+                                    const columnEntries = {};
+                                    for (const col of Object.keys(capturedCodec.attributes)) {
+                                        columnEntries[col] = (0, grafast_1.access)($row, col);
+                                    }
+                                    return (0, grafast_1.object)(columnEntries);
+                                },
+                            });
+                        }
+                        return build.extend(fields, newFields, 'PresignedUrlPlugin adding per-bucket mutation entry points');
+                    }
+                    // --- Path 2: Add upload fields on @storageBuckets types ---
                     if (!isPgClassType || !pgCodec || !pgCodec.attributes) {
                         return fields;
                     }