graphile-bucket-provisioner-plugin 1.14.2 → 1.15.0

package/esm/plugin.js

@@ -3,26 +3,18 @@
  *
  * Adds S3 bucket provisioning support to PostGraphile v5:
  *
- * 1. `provisionBucket` mutation — explicitly provision an S3 bucket for a
+ * 1. `provisionBucket` mutation — explicitly enqueue reconciliation for a
  *    logical bucket row in the database. Reads the bucket config via RLS,
- *    then calls BucketProvisioner to create and configure the S3 bucket.
- *
- * This plugin uses `@constructive-io/bucket-provisioner` for the actual
- * S3 operations (bucket creation, Block Public Access, CORS, policies,
- * versioning, lifecycle rules).
+ *    then queues the same storage reconciler job used by the INSERT trigger.
  *
  * Detection: Uses the `@storageBuckets` smart tag on the codec (table).
  * The storage module generator in constructive-db sets this tag on the
  * generated buckets table via a smart comment:
  *   COMMENT ON TABLE buckets IS E'@storageBuckets\nStorage buckets table';
  */
-import { BucketProvisioner, } from '@constructive-io/bucket-provisioner';
-import { Logger } from '@pgpmjs/logger';
 import { QuoteUtils } from '@pgsql/quotes';
 import { context as grafastContext, lambda, object } from 'grafast';
-import { recordPhysicalName as recordPhysicalBucketName } from 'graphile-storage-registry';
 import { extendSchema, gql } from 'graphile-utils';
-const log = new Logger('graphile-bucket-provisioner:plugin');
 // --- Storage module queries ---
 /**
  * Resolve ALL storage modules for a database (for bucket-key and ownerId-based
@@ -31,7 +23,10 @@ const log = new Logger('graphile-bucket-provisioner:plugin');
 const ALL_STORAGE_MODULES_QUERY = `
   SELECT
     sm.id,
+    sm.database_id,
+    sm.buckets_table_id,
     sm.scope,
+    sm.entity_field,
     sm.entity_table_id,
     bs.schema_name AS buckets_schema,
     bt.name AS buckets_table,
@@ -59,6 +54,17 @@ const ALL_STORAGE_MODULES_QUERY = `
 function runQuery(pgClient, text, values) {
     return pgClient.query(values === undefined ? { text } : { text, values });
 }
+function scopeKeySelect(storageModule) {
+    return storageModule.entity_field === null
+        ? ''
+        : `, ${QuoteUtils.quoteIdentifier(storageModule.entity_field)} AS scope_key`;
+}
+function scopeKeyColumn(storageModule) {
+    if (storageModule.entity_field === null) {
+        throw new Error(`STORAGE_BUCKET_SCOPE_KEY_MISSING: storage module ${storageModule.id} has no entity field`);
+    }
+    return QuoteUtils.quoteIdentifier(storageModule.entity_field);
+}
 /**
  * The explicit provisionBucket mutation's resolution: find the plane that
  * actually holds the named bucket row.
@@ -83,9 +89,9 @@ async function resolveBucketByKey(pgClient, databaseId, bucketKey, ownerId) {
             if (probe.rows.length === 0)
                 continue;
             const bucketsTable = QuoteUtils.quoteQualifiedIdentifier(mod.buckets_schema, mod.buckets_table);
-            const bucketResult = await runQuery(pgClient, `SELECT id, key, type, is_public, allowed_origins, physical_name
+            const bucketResult = await runQuery(pgClient, `SELECT id, key, type, is_public, allowed_origins, physical_name${scopeKeySelect(mod)}
          FROM ${bucketsTable}
-         WHERE key = $1 AND owner_id = $2
+         WHERE key = $1 AND ${scopeKeyColumn(mod)} = $2
          LIMIT 1`, [bucketKey, ownerId]);
             if (bucketResult.rows.length === 0)
                 return null;
@@ -96,7 +102,7 @@ async function resolveBucketByKey(pgClient, databaseId, bucketKey, ownerId) {
     const matches = [];
     for (const mod of modules.filter((m) => m.entity_table_id === null)) {
         const bucketsTable = QuoteUtils.quoteQualifiedIdentifier(mod.buckets_schema, mod.buckets_table);
-        const bucketResult = await runQuery(pgClient, `SELECT id, key, type, is_public, allowed_origins, physical_name
+        const bucketResult = await runQuery(pgClient, `SELECT id, key, type, is_public, allowed_origins, physical_name${scopeKeySelect(mod)}
        FROM ${bucketsTable}
        WHERE key = $1
        LIMIT 1`, [bucketKey]);
@@ -113,43 +119,7 @@ async function resolveBucketByKey(pgClient, databaseId, bucketKey, ownerId) {
     }
     return matches[0];
 }
-/**
- * Normalize the recorded physical coordinate at the DB boundary.
- *
- * A bucket row either carries a recorded coordinate or it does not; SQL nulls
- * and absent columns both mean "never provisioned". Collapsing them here is
- * the single place that shape is interpreted — callers branch on `string`
- * vs `null` and never coalesce a bucket name into existence.
- */
-function storedPhysicalName(row) {
-    return row.physical_name == null ? null : row.physical_name;
-}
 // --- Helpers ---
-/**
- * Resolve the connection config from the options. If the option is a lazy
- * getter function, call it (and cache the result).
- */
-function resolveConnection(options) {
-    if (typeof options.connection === 'function') {
-        const resolved = options.connection();
-        // Cache so subsequent calls don't re-evaluate
-        options.connection = resolved;
-        return resolved;
-    }
-    return options.connection;
-}
-/**
- * Resolve the S3 bucket name from a logical bucket key.
- */
-function resolveBucketName(databaseId, bucketKey, options) {
-    if (!options.resolveBucketName) {
-        throw new Error('STORAGE_BUCKET_NAME_POLICY_MISSING: no resolveBucketName was configured, so there is ' +
-            `no name to provision for bucket "${bucketKey}" of database ${databaseId}. ` +
-            'Physical bucket naming is a deployment policy; the configured s3.bucket is a ' +
-            'connection default and is never a tenant bucket.');
-    }
-    return options.resolveBucketName(databaseId, bucketKey);
-}
 /**
  * Resolve the database_id from the JWT context.
  */
@@ -157,72 +127,110 @@ async function resolveDatabaseId(pgClient) {
     const result = await runQuery(pgClient, `SELECT jwt_private.current_database_id() AS id`);
     return result.rows[0]?.id ?? null;
 }
-/**
- * Resolve the effective CORS allowed origins using the 3-tier hierarchy:
- *   1. Bucket-level allowed_origins (per-bucket override)
- *   2. Storage-module-level allowed_origins (per-database default)
- *   3. Plugin config allowedOrigins (global fallback)
- */
-function resolveAllowedOrigins(bucketOrigins, storageModuleOrigins, pluginOrigins) {
-    if (bucketOrigins && bucketOrigins.length > 0) {
-        return bucketOrigins;
-    }
-    if (storageModuleOrigins && storageModuleOrigins.length > 0) {
-        return storageModuleOrigins;
-    }
-    return pluginOrigins;
-}
-/**
- * Build a BucketProvisioner with per-database connection overrides.
- */
-function buildProvisioner(options, storageModule, effectiveOrigins) {
-    const connection = resolveConnection(options);
-    const effectiveConnection = {
-        ...connection,
-        ...(storageModule?.endpoint ? { endpoint: storageModule.endpoint } : {}),
-        ...(storageModule?.provider
-            ? { provider: storageModule.provider }
-            : {}),
+async function resolveEntityContext(pgClient, storageModule) {
+    const result = await runQuery(pgClient, `SELECT r.entity_type, r.get_org_fn_schema, r.get_org_fn
+     FROM metaschema.resolve_entity_context_by_field($1::uuid, $2::uuid, $3::text) r`, [storageModule.database_id, storageModule.buckets_table_id, storageModule.entity_field]);
+    return result.rows[0] ?? {
+        entity_type: null,
+        get_org_fn_schema: null,
+        get_org_fn: null,
     };
-    return new BucketProvisioner({
-        connection: effectiveConnection,
-        allowedOrigins: effectiveOrigins,
-    });
 }
 /**
- * Core provisioning logic for the explicit mutation.
+ * Mirror the storage module generator's data_job_trigger shape from
+ * `packages/metaschema-generators/deploy/schemas/metaschema_generators/procedures/storage_module.sql`
+ * and the add_job argument assembly in
+ * `packages/ast-plpgsql/deploy/schemas/ast_plpgsql_helpers/procedures/triggers/job_trigger.sql`.
+ * A callable enqueue function beside the trigger would be the durable fix for
+ * this deliberate mirroring, but is out of scope here.
  */
-async function provisionBucketForRow(storageModule, databaseId, bucketKey, bucketType, bucketAllowedOrigins, options, s3BucketName) {
-    const accessType = bucketType;
-    // Resolve CORS origins using the 3-tier hierarchy
-    const effectiveOrigins = resolveAllowedOrigins(bucketAllowedOrigins, storageModule?.allowed_origins, options.allowedOrigins);
-    const provisioner = buildProvisioner(options, storageModule, effectiveOrigins);
-    log.info(`Provisioning S3 bucket "${s3BucketName}" (key="${bucketKey}", type="${accessType}", ` +
-        `origins=${JSON.stringify(effectiveOrigins)}) for database ${databaseId}`);
-    const result = await provisioner.provision({
-        bucketName: s3BucketName,
-        accessType,
-        versioning: options.versioning ?? false,
-        publicUrlPrefix: storageModule?.public_url_prefix ?? undefined,
-        allowedOrigins: effectiveOrigins,
-    });
-    log.info(`Successfully provisioned S3 bucket "${s3BucketName}" ` +
-        `(provider=${result.provider}, blockPublicAccess=${result.blockPublicAccess})`);
-    return result;
+async function enqueueReconciliationJob(pgClient, storageModule, bucket) {
+    const scope = storageModule.scope;
+    const entityField = storageModule.entity_field;
+    let text;
+    let values;
+    if (entityField === null) {
+        text = `SELECT (app_jobs.add_job(
+      identifier => 'storage:provision_bucket',
+      payload => json_build_object(
+        'id', $1::uuid,
+        'scope', $2::text
+      ),
+      queue_name => 'bucket:' || $1::text,
+      max_attempts => 25,
+      priority => 0
+    )).id AS id`;
+        values = [bucket.id, scope];
+    }
+    else if (entityField === 'database_id') {
+        const databaseId = bucket.scope_key;
+        if (!databaseId) {
+            throw new Error(`STORAGE_BUCKET_SCOPE_KEY_MISSING: bucket ${bucket.id} has no database_id`);
+        }
+        text = `SELECT (app_jobs.add_job(
+      identifier => 'storage:provision_bucket',
+      payload => json_build_object(
+        'database_id', $2::uuid,
+        'id', $1::uuid,
+        'scope', $3::text
+      ),
+      db_id => $2,
+      queue_name => 'bucket:' || $1::text,
+      max_attempts => 25,
+      priority => 0,
+      entity_id => $2,
+      organization_id => NULL,
+      entity_type => $3
+    )).id AS id`;
+        values = [bucket.id, databaseId, scope];
+    }
+    else if (entityField === 'owner_id') {
+        const ownerId = bucket.scope_key;
+        if (!ownerId) {
+            throw new Error(`STORAGE_BUCKET_SCOPE_KEY_MISSING: bucket ${bucket.id} has no owner_id`);
+        }
+        const context = await resolveEntityContext(pgClient, storageModule);
+        const orgFunction = context.get_org_fn_schema && context.get_org_fn
+            ? `${QuoteUtils.quoteQualifiedIdentifier(context.get_org_fn_schema, context.get_org_fn)}($3::text, $2::uuid)`
+            : 'NULL';
+        text = `SELECT (app_jobs.add_job(
+      identifier => 'storage:provision_bucket',
+      payload => json_build_object(
+        'id', $1::uuid,
+        'owner_id', $2::uuid,
+        'scope', $3::text
+      ),
+      queue_name => 'bucket:' || $1::text,
+      max_attempts => 25,
+      priority => 0,
+      entity_id => $2,
+      organization_id => ${orgFunction},
+      entity_type => $3
+    )).id AS id`;
+        values = [bucket.id, ownerId, scope];
+    }
+    else {
+        throw new Error(`STORAGE_BUCKET_ENTITY_FIELD_UNSUPPORTED: ${entityField}`);
+    }
+    const result = await runQuery(pgClient, text, values);
+    const jobId = result.rows[0]?.id;
+    if (!jobId) {
+        throw new Error(`STORAGE_BUCKET_JOB_ID_MISSING: bucket ${bucket.id}`);
+    }
+    return jobId;
 }
 // --- Plugin factory ---
 /**
  * Creates the bucket provisioner plugin.
  *
- * This plugin provides one provisioning pathway:
+ * This plugin provides one reconciliation pathway:
  *
  * 1. **Explicit `provisionBucket` mutation** — Call this mutation with a
- *    bucket key to provision (or re-provision) the S3 bucket. Protected
- *    by RLS on the buckets table.
+ *    bucket key to enqueue reconciliation (or re-reconciliation) for the
+ *    bucket. Protected by RLS on the buckets table.
  *
- * @param options - Plugin configuration (S3 credentials, CORS origins, naming)
  */
-export function createBucketProvisionerPlugin(options) {
+export function createBucketProvisionerPlugin() {
     // The extendSchema plugin adds the explicit provisionBucket mutation
     const mutationPlugin = extendSchema(() => ({
         typeDefs: gql `
@@ -237,26 +245,22 @@ export function createBucketProvisionerPlugin(options) {
       }
 
       type ProvisionBucketPayload {
-        """Whether provisioning succeeded"""
-        success: Boolean!
-        """The S3 bucket name that was provisioned"""
-        bucketName: String!
-        """The access type applied"""
-        accessType: String!
-        """The storage provider used"""
-        provider: String!
-        """The S3 endpoint (null for AWS S3 default)"""
-        endpoint: String
-        """Error message if provisioning failed"""
-        error: String
+        """The logical bucket row that was queued for reconciliation."""
+        bucketId: UUID!
+        bucketKey: String!
+        """The physical bucket name already recorded, or null when reconciliation has not completed."""
+        physicalName: String
+        """The reconciler job enqueued to provision this bucket."""
+        jobId: UUID!
       }
 
       extend type Mutation {
         """
-        Provision an S3 bucket for a logical bucket in the database.
-        Reads the bucket config via RLS, then creates and configures
-        the S3 bucket with the appropriate privacy policies, CORS rules,
-        and lifecycle settings.
+        Reconcile an S3 bucket for a logical bucket in the database.
+        Reads the bucket config via RLS, then enqueues the same
+        storage:provision_bucket job used by the INSERT trigger. This is
+        idempotent for an already-reconciled bucket; enqueue failures become
+        GraphQL errors.
         """
         provisionBucket(
           input: ProvisionBucketInput!
@@ -292,38 +296,13 @@ export function createBucketProvisionerPlugin(options) {
                                 throw new Error('BUCKET_NOT_FOUND');
                             }
                             const { storageModule, bucket } = resolution;
-                            const bucketsTable = QuoteUtils.quoteQualifiedIdentifier(storageModule.buckets_schema, storageModule.buckets_table);
-                            // First provision mints a name; afterwards the stored coordinate
-                            // is authoritative and the naming hook is never consulted again.
-                            const recorded = storedPhysicalName(bucket);
-                            const s3BucketName = recorded === null
-                                ? resolveBucketName(databaseId, bucket.key, options)
-                                : recorded;
-                            try {
-                                const result = await provisionBucketForRow(storageModule, databaseId, bucket.key, bucket.type, bucket.allowed_origins, options, s3BucketName);
-                                // Record the exact provisioned name on the source row.
-                                await withPgClient(null, (client) => recordPhysicalBucketName((query) => runQuery(client, query.text, query.values), bucketsTable, bucket.id, result.bucketName));
-                                log.info(`Recorded physical_name="${result.bucketName}" on bucket ${bucket.id}`);
-                                return {
-                                    success: true,
-                                    bucketName: result.bucketName,
-                                    accessType: result.accessType,
-                                    provider: result.provider,
-                                    endpoint: result.endpoint,
-                                    error: null,
-                                };
-                            }
-                            catch (err) {
-                                log.error(`Failed to provision bucket "${bucketKey}": ${err.message}`);
-                                return {
-                                    success: false,
-                                    bucketName: s3BucketName,
-                                    accessType: bucket.type,
-                                    provider: resolveConnection(options).provider,
-                                    endpoint: resolveConnection(options).endpoint ?? null,
-                                    error: err.message,
-                                };
-                            }
+                            const jobId = await enqueueReconciliationJob(pgClient, storageModule, bucket);
+                            return {
+                                bucketId: bucket.id,
+                                bucketKey: bucket.key,
+                                physicalName: bucket.physical_name,
+                                jobId,
+                            };
                         });
                     });
                 },

package/esm/preset.d.ts

@@ -5,36 +5,8 @@
  * in PostGraphile. Wraps the main plugin with sensible defaults.
  */
 import type { GraphileConfig } from 'graphile-config';
-import type { BucketProvisionerPluginOptions } from './types';
 /**
- * Creates a preset that includes the bucket provisioner plugin with the given options.
- *
- * @example
- * ```typescript
- * import { BucketProvisionerPreset } from 'graphile-bucket-provisioner-plugin';
- * import { getEnvOptions } from '@constructive-io/graphql-env';
- *
- * // Use a lazy getter so env vars are read at runtime, not import time
- * function getConnection() {
- *   const { cdn } = getEnvOptions();
- *   return {
- *     provider: cdn?.provider || 'minio',
- *     region: cdn?.awsRegion || 'us-east-1',
- *     endpoint: cdn?.endpoint || 'http://minio:9000',
- *     accessKeyId: cdn?.awsAccessKey!,
- *     secretAccessKey: cdn?.awsSecretKey!,
- *   };
- * }
- *
- * const preset = {
- *   extends: [
- *     BucketProvisionerPreset({
- *       connection: getConnection, // pass function ref, NOT getConnection()
- *       allowedOrigins: ['https://app.example.com'],
- *     }),
- *   ],
- * };
- * ```
+ * Creates a preset that includes the bucket reconciliation plugin.
  */
-export declare function BucketProvisionerPreset(options: BucketProvisionerPluginOptions): GraphileConfig.Preset;
+export declare function BucketProvisionerPreset(): GraphileConfig.Preset;
 export default BucketProvisionerPreset;

package/esm/preset.js

@@ -6,38 +6,11 @@
  */
 import { createBucketProvisionerPlugin } from './plugin';
 /**
- * Creates a preset that includes the bucket provisioner plugin with the given options.
- *
- * @example
- * ```typescript
- * import { BucketProvisionerPreset } from 'graphile-bucket-provisioner-plugin';
- * import { getEnvOptions } from '@constructive-io/graphql-env';
- *
- * // Use a lazy getter so env vars are read at runtime, not import time
- * function getConnection() {
- *   const { cdn } = getEnvOptions();
- *   return {
- *     provider: cdn?.provider || 'minio',
- *     region: cdn?.awsRegion || 'us-east-1',
- *     endpoint: cdn?.endpoint || 'http://minio:9000',
- *     accessKeyId: cdn?.awsAccessKey!,
- *     secretAccessKey: cdn?.awsSecretKey!,
- *   };
- * }
- *
- * const preset = {
- *   extends: [
- *     BucketProvisionerPreset({
- *       connection: getConnection, // pass function ref, NOT getConnection()
- *       allowedOrigins: ['https://app.example.com'],
- *     }),
- *   ],
- * };
- * ```
+ * Creates a preset that includes the bucket reconciliation plugin.
  */
-export function BucketProvisionerPreset(options) {
+export function BucketProvisionerPreset() {
     return {
-        plugins: [createBucketProvisionerPlugin(options)],
+        plugins: [createBucketProvisionerPlugin()],
     };
 }
 export default BucketProvisionerPreset;

package/esm/types.d.ts

@@ -1,50 +1,6 @@
 /**
  * Types for the bucket provisioner plugin.
  */
-import type { BucketAccessType, ProvisionResult, StorageConnectionConfig, StorageProvider } from '@constructive-io/bucket-provisioner';
-export type { BucketAccessType, ProvisionResult, StorageConnectionConfig, StorageProvider };
-/**
- * S3 connection configuration or a lazy getter that returns it on first use.
- *
- * When a function is provided, it will only be called when the first
- * provisioning operation actually needs the S3 client — avoiding eager
- * env-var reads and S3Client creation at module import time.
- */
-export type ConnectionConfigOrGetter = StorageConnectionConfig | (() => StorageConnectionConfig);
-/**
- * Function to derive the actual S3 bucket name from a logical bucket key.
- *
- * @param databaseId - The metaschema database UUID
- * @param bucketKey - The logical bucket key from the database (e.g., "public", "private")
- * @returns The S3 bucket name to create/configure
- */
-export type BucketNameResolver = (databaseId: string, bucketKey: string) => string;
-/**
- * Plugin options for the bucket provisioner plugin.
- */
-export interface BucketProvisionerPluginOptions {
-    /**
-     * S3 connection configuration (credentials, endpoint, provider).
-     * Can be a concrete object or a lazy getter function.
-     */
-    connection: ConnectionConfigOrGetter;
-    /**
-     * Allowed origins for CORS rules on provisioned buckets.
-     * These are the domains where your app runs (e.g., ["https://app.example.com"]).
-     * Required for browser-based presigned URL uploads.
-     */
-    allowedOrigins: string[];
-    /**
-     * Optional custom function to derive S3 bucket names from logical bucket keys.
-     * Naming is a deployment policy and must be supplied by the caller.
-     */
-    resolveBucketName?: BucketNameResolver;
-    /**
-     * Whether to enable versioning on provisioned buckets.
-     * Default: false
-     */
-    versioning?: boolean;
-}
 /**
  * Input for the provisionBucket mutation.
  */
@@ -58,19 +14,15 @@ export interface ProvisionBucketInput {
     ownerId?: string;
 }
 /**
- * Result of the provisionBucket mutation.
+ * Result of the provisionBucket reconciliation enqueue mutation.
  */
 export interface ProvisionBucketPayload {
-    /** Whether provisioning succeeded */
-    success: boolean;
-    /** The S3 bucket name that was provisioned */
-    bucketName: string;
-    /** The access type applied */
-    accessType: string;
-    /** The storage provider used */
-    provider: string;
-    /** The S3 endpoint (null for AWS S3 default) */
-    endpoint: string | null;
-    /** Error message if provisioning failed */
-    error: string | null;
+    /** The logical bucket row queued for reconciliation */
+    bucketId: string;
+    /** The logical bucket key */
+    bucketKey: string;
+    /** The physical name already recorded, or null while reconciliation is pending */
+    physicalName: string | null;
+    /** The queued reconciler job */
+    jobId: string;
 }

package/index.d.ts

@@ -1,35 +1,9 @@
 /**
  * Bucket Provisioner Plugin for PostGraphile v5
  *
- * Provides an explicit `provisionBucket` mutation for PostGraphile v5.
- *
- * @example
- * ```typescript
- * import { BucketProvisionerPreset } from 'graphile-bucket-provisioner-plugin';
- * import { getEnvOptions } from '@constructive-io/graphql-env';
- *
- * // Use a lazy getter so env vars are read at runtime, not import time
- * function getConnection() {
- *   const { cdn } = getEnvOptions();
- *   return {
- *     provider: cdn?.provider || 'minio',
- *     region: cdn?.awsRegion || 'us-east-1',
- *     endpoint: cdn?.endpoint || 'http://minio:9000',
- *     accessKeyId: cdn?.awsAccessKey!,
- *     secretAccessKey: cdn?.awsSecretKey!,
- *   };
- * }
- *
- * const preset = {
- *   extends: [
- *     BucketProvisionerPreset({
- *       connection: getConnection, // pass function ref, NOT getConnection()
- *       allowedOrigins: ['https://app.example.com'],
- *     }),
- *   ],
- * };
- * ```
+ * Provides an explicit `provisionBucket` reconciliation enqueue mutation for
+ * PostGraphile v5.
  */
 export { BucketProvisionerPlugin, createBucketProvisionerPlugin } from './plugin';
 export { BucketProvisionerPreset } from './preset';
-export type { BucketAccessType, BucketNameResolver, BucketProvisionerPluginOptions, ConnectionConfigOrGetter, ProvisionBucketInput, ProvisionBucketPayload, ProvisionResult, StorageConnectionConfig, StorageProvider, } from './types';
+export type { ProvisionBucketInput, ProvisionBucketPayload, } from './types';

package/index.js

@@ -2,34 +2,8 @@
 /**
  * Bucket Provisioner Plugin for PostGraphile v5
  *
- * Provides an explicit `provisionBucket` mutation for PostGraphile v5.
- *
- * @example
- * ```typescript
- * import { BucketProvisionerPreset } from 'graphile-bucket-provisioner-plugin';
- * import { getEnvOptions } from '@constructive-io/graphql-env';
- *
- * // Use a lazy getter so env vars are read at runtime, not import time
- * function getConnection() {
- *   const { cdn } = getEnvOptions();
- *   return {
- *     provider: cdn?.provider || 'minio',
- *     region: cdn?.awsRegion || 'us-east-1',
- *     endpoint: cdn?.endpoint || 'http://minio:9000',
- *     accessKeyId: cdn?.awsAccessKey!,
- *     secretAccessKey: cdn?.awsSecretKey!,
- *   };
- * }
- *
- * const preset = {
- *   extends: [
- *     BucketProvisionerPreset({
- *       connection: getConnection, // pass function ref, NOT getConnection()
- *       allowedOrigins: ['https://app.example.com'],
- *     }),
- *   ],
- * };
- * ```
+ * Provides an explicit `provisionBucket` reconciliation enqueue mutation for
+ * PostGraphile v5.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketProvisionerPreset = exports.createBucketProvisionerPlugin = exports.BucketProvisionerPlugin = void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-bucket-provisioner-plugin",
-  "version": "1.14.2",
+  "version": "1.15.0",
   "description": "Bucket provisioning plugin for PostGraphile v5 — explicitly provisions S3 buckets via a GraphQL mutation",
   "author": "Constructive <developers@constructive.io>",
   "homepage": "https://github.com/constructive-io/constructive",
@@ -40,7 +40,7 @@
     "url": "https://github.com/constructive-io/constructive/issues"
   },
   "dependencies": {
-    "@constructive-io/bucket-provisioner": "^0.26.0",
+    "@constructive-io/bucket-provisioner": "^0.27.0",
     "@pgpmjs/logger": "^2.25.0",
     "@pgsql/quotes": "^18.2.4",
     "graphile-storage-registry": "^0.1.1"
@@ -58,5 +58,5 @@
     "@types/node": "^22.19.11",
     "makage": "^0.3.0"
   },
-  "gitHead": "ec6638bb4a06080919cee7e9ebf48306a2535f2f"
+  "gitHead": "77d58bb93796be91d4e00156bb6847392584d3bc"
 }