@contember/engine-s3-plugin 1.2.1 → 1.3.0-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-s3-plugin",
-  "version": "1.2.1",
+  "version": "1.3.0-alpha.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -8,9 +8,9 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@contember/engine-plugins": "^1.2.1",
-    "@contember/graphql-utils": "^1.2.1",
-    "@contember/typesafe": "^1.2.1",
+    "@contember/engine-plugins": "^1.3.0-alpha.2",
+    "@contember/graphql-utils": "^1.3.0-alpha.2",
+    "@contember/typesafe": "^1.3.0-alpha.2",
     "mime-types": "^2.1.24",
     "picomatch": "^2.2.1",
     "qs": "^6.10.1",

package/src/Config.ts

@@ -1,4 +1,3 @@
-import { ProjectConfig } from '@contember/engine-plugins'
 import * as Typesafe from '@contember/typesafe'
 
 export enum S3Providers {
@@ -30,7 +29,7 @@ export const s3ConfigSchema = Typesafe.intersection(
 
 export type S3Config = ReturnType<typeof s3ConfigSchema>
 
-export type ProjectWithS3Config = ProjectConfig<{ s3?: S3Config }>
+export type Project3Config = { s3?: S3Config }
 
 // todo
 const serversWithoutAclSupport = [S3Providers.minio]

package/src/S3ConfigProcessor.ts

@@ -1,8 +1,8 @@
 import { ConfigProcessor, ConfigTemplate, ConfigTemplateContext } from '@contember/engine-plugins'
-import { ProjectWithS3Config, s3ConfigSchema } from './Config'
+import { Project3Config, s3ConfigSchema } from './Config'
 import * as Typesafe from '@contember/typesafe'
 
-export class S3ConfigProcessor implements ConfigProcessor<ProjectWithS3Config> {
+export class S3ConfigProcessor implements ConfigProcessor<Project3Config> {
 	getDefaultEnv(): Record<string, string> {
 		return {
 			DEFAULT_S3_ENDPOINT: '',

package/src/S3ObjectAuthorizator.ts

@@ -0,0 +1,63 @@
+import pm from 'picomatch'
+import { ForbiddenError } from '@contember/graphql-utils'
+
+export type S3ObjectUploadRule = {
+	pattern: string
+	maxSize?: number
+	matcher?: (key: string) => boolean
+}
+
+export type S3ObjectReadRule = {
+	pattern: string
+	matcher?: (key: string) => boolean
+}
+
+export class S3ObjectAuthorizator {
+	private readonly uploadRules: S3ObjectUploadRule[]
+	private readonly readRules: S3ObjectReadRule[]
+
+	constructor(
+		uploadRules: Omit<S3ObjectUploadRule, 'matcher'>[],
+		readRules: Omit<S3ObjectReadRule, 'matcher'>[],
+	) {
+		this.uploadRules = uploadRules
+		this.readRules = readRules
+	}
+
+	public verifyReadAccess({ key }: { key: string }): void {
+		for (const rule of this.readRules) {
+			rule.matcher ??= pm(rule.pattern)
+
+			if (rule.matcher(key)) {
+				return
+			}
+		}
+
+		throw new ForbiddenError(`Read access forbidden for object key ${key}`)
+	}
+
+	public verifyUploadAccess({ key, size }: { key: string; size: number | null }): void {
+		const matchedPatterns: S3ObjectUploadRule[] = []
+
+		for (const rule of this.uploadRules) {
+			rule.matcher ??= pm(rule.pattern)
+
+			if (rule.matcher(key)) {
+				if (!rule.maxSize || (size !== null && size <= rule.maxSize)) {
+					return
+				}
+				matchedPatterns.push(rule)
+			}
+		}
+
+		if (matchedPatterns.length > 0) {
+			if (size === null) {
+				throw new ForbiddenError('File size must be provided')
+			} else {
+				throw new ForbiddenError('Uploaded file is too large')
+			}
+		}
+
+		throw new ForbiddenError(`Upload access forbidden for object key ${key}`)
+	}
+}

package/src/S3SchemaContributor.ts

@@ -1,61 +1,51 @@
 import {
-	GraphQLEnumType,
 	GraphQLFieldConfig,
 	GraphQLInt,
-	GraphQLList,
 	GraphQLNonNull,
 	GraphQLObjectType,
 	GraphQLSchema,
 	GraphQLString,
 } from 'graphql'
-import { S3Acl, S3Service, S3ServiceFactory } from './S3Service'
+import { S3Service, S3ServiceFactory } from './S3Service'
 import { resolveS3Config, S3Config } from './Config'
-import { createObjectKeyVerifier, ObjectKeyVerifier } from './ObjectKeyVerifier'
-import { GraphQLSchemaContributor, SchemaContext } from '@contember/engine-plugins'
-import { Providers } from '@contember/engine-plugins'
+import { GraphQLSchemaContributor, Providers, GraphQLSchemaContributorContext } from '@contember/engine-plugins'
+import * as types from './S3SchemaTypes'
+import { S3Acl, S3GenerateSignedUploadInput, S3SignedRead, S3SignedUpload } from './S3SchemaTypes'
+import { S3ObjectAuthorizator } from './S3ObjectAuthorizator'
 
 interface Identity {
 	projectRoles: string[]
 }
 
-type S3SchemaAcl = Record<
+export type S3SchemaUploadAcl =
+	| boolean
+	| {
+		maxSize?: number
+	}
+
+export type S3SchemaAcl = Record<
 	string, // public/*.jpg
 	{
 		read?: boolean
-		upload?: boolean
+		upload?: S3SchemaUploadAcl
 	}
 >
 
-export class S3SchemaContributor implements GraphQLSchemaContributor {
-	private s3HeadersType: GraphQLFieldConfig<any, any> = {
-		type: new GraphQLNonNull(
-			new GraphQLList(
-				new GraphQLNonNull(
-					new GraphQLObjectType({
-						name: 'S3Header',
-						fields: {
-							key: { type: new GraphQLNonNull(GraphQLString) },
-							value: { type: new GraphQLNonNull(GraphQLString) },
-						},
-					}),
-				),
-			),
-		),
-	}
 
+export class S3SchemaContributor implements GraphQLSchemaContributor {
 	constructor(
 		private readonly s3Config: S3Config | undefined,
 		private readonly s3Factory: S3ServiceFactory,
 		private readonly providers: Providers,
 	) {}
 
-	getCacheKey(context: SchemaContext): string {
+	getCacheKey(context: GraphQLSchemaContributorContext): string {
 		const roles = context.identity.projectRoles
 		roles.sort()
 		return roles.join('||')
 	}
 
-	createSchema(context: SchemaContext): GraphQLSchema | undefined {
+	createSchema(context: GraphQLSchemaContributorContext): GraphQLSchema | undefined {
 		if (!this.s3Config) {
 			return undefined
 		}
@@ -63,17 +53,24 @@ export class S3SchemaContributor implements GraphQLSchemaContributor {
 			Object.entries((context.schema.acl.roles[it]?.s3 as S3SchemaAcl) || {}),
 		)
 
-		const allowedUploads = rules.filter(([, it]) => it.upload).map(([it]) => it)
-		const allowedReads = rules.filter(([, it]) => it.read).map(([it]) => it)
 
-		if (allowedUploads.length === 0 && allowedReads.length == 0) {
+		const uploadRules = rules.filter(([, it]) => it.upload).map(([it, val]) => ({
+			pattern: it,
+			...(typeof val.upload !== 'boolean' ? val.upload : {}),
+		}))
+		const readRules = rules.filter(([, it]) => it.read).map(([it]) => ({
+			pattern: it,
+		}))
+
+		if (uploadRules.length === 0 && readRules.length == 0) {
 			return undefined
 		}
 
 		const s3Config = resolveS3Config(this.s3Config)
-		const s3 = this.s3Factory.create(s3Config, this.providers)
-		const uploadMutation = this.createUploadMutation(s3Config, s3, allowedUploads)
-		const readMutation = this.createReadMutation(s3, allowedReads)
+		const authorizator = new S3ObjectAuthorizator(uploadRules, readRules)
+		const s3 = this.s3Factory.create(s3Config, this.providers, authorizator)
+		const uploadMutation = this.createUploadMutation(s3)
+		const readMutation = this.createReadMutation(s3)
 		const mutation = {
 			generateUploadUrl: uploadMutation as GraphQLFieldConfig<any, any, any>,
 			generateReadUrl: readMutation,
@@ -94,24 +91,9 @@ export class S3SchemaContributor implements GraphQLSchemaContributor {
 		})
 	}
 
-	private createReadMutation(s3: S3Service, allowedKeyPatterns: string[]): GraphQLFieldConfig<any, any, any> {
-		let verifier: ObjectKeyVerifier
+	private createReadMutation(s3: S3Service): GraphQLFieldConfig<any, any, any> {
 		return {
-			type: new GraphQLNonNull(
-				new GraphQLObjectType({
-					name: 'S3SignedRead',
-					fields: {
-						url: { type: new GraphQLNonNull(GraphQLString) },
-						headers: this.s3HeadersType,
-						method: { type: new GraphQLNonNull(GraphQLString) },
-						objectKey: {
-							type: new GraphQLNonNull(GraphQLString),
-							description: `Allowed patterns:\n${allowedKeyPatterns.join('\n')}`,
-						},
-						bucket: { type: new GraphQLNonNull(GraphQLString) },
-					},
-				}),
-			),
+			type: new GraphQLNonNull(S3SignedRead),
 			args: {
 				objectKey: {
 					type: new GraphQLNonNull(GraphQLString),
@@ -121,76 +103,36 @@ export class S3SchemaContributor implements GraphQLSchemaContributor {
 				},
 			},
 			resolve: async (parent: any, args: { objectKey: string; expiration?: number }) => {
-				if (!verifier) {
-					verifier = createObjectKeyVerifier(allowedKeyPatterns)
-				}
-				return s3.getSignedReadUrl(args.objectKey, verifier, args.expiration)
+				return s3.getSignedReadUrl({ objectKey: args.objectKey, expiration: args.expiration ?? null })
 			},
 		} as GraphQLFieldConfig<any, any, any>
 	}
 
-	private createUploadMutation(
-		s3Config: S3Config,
-		s3: S3Service,
-		allowedKeyPatterns: string[],
-	): GraphQLFieldConfig<any, any, any> {
-		let verifier: ObjectKeyVerifier
+	private createUploadMutation(s3: S3Service): GraphQLFieldConfig<any, any, any> {
 		return {
-			type: new GraphQLNonNull(
-				new GraphQLObjectType({
-					name: 'S3SignedUpload',
-					fields: {
-						url: { type: new GraphQLNonNull(GraphQLString) },
-						headers: this.s3HeadersType,
-						method: { type: new GraphQLNonNull(GraphQLString) },
-						objectKey: {
-							type: new GraphQLNonNull(GraphQLString),
-							description: `Allowed patterns:\n${allowedKeyPatterns.join('\n')}`,
-						},
-						bucket: { type: new GraphQLNonNull(GraphQLString) },
-						publicUrl: { type: new GraphQLNonNull(GraphQLString) },
-					},
-				}),
-			),
+			type: new GraphQLNonNull(S3SignedUpload),
 			args: {
-				contentType: {
-					type: new GraphQLNonNull(GraphQLString),
-				},
-				expiration: {
-					type: GraphQLInt,
-				},
-				prefix: {
-					type: GraphQLString,
-				},
-				...(s3Config.noAcl
-					? {}
-					: {
-						acl: {
-							type: new GraphQLEnumType({
-								name: 'S3Acl',
-								values: {
-									PUBLIC_READ: {},
-									PRIVATE: {},
-									NONE: {},
-								},
-							}),
-						},
-					  }),
+				input: { type: types.S3GenerateSignedUploadInput },
+				contentType: { type: GraphQLString, deprecationReason: 'Use input.contentType' },
+				expiration: { type: GraphQLInt, deprecationReason: 'Use input.expiration' },
+				prefix: { type: GraphQLString, deprecationReason: 'Use input.prefix' },
+				acl: { type: types.S3Acl, deprecationReason: 'Use input.acl' },
 			},
 			resolve: async (
 				parent: any,
-				args: { contentType: string; acl?: string; expiration?: number; prefix?: string },
+				args: { input?: Partial<S3GenerateSignedUploadInput>; contentType?: string; acl?: S3Acl; expiration?: number; prefix?: string },
 			) => {
-				if (!verifier) {
-					verifier = createObjectKeyVerifier(allowedKeyPatterns)
-				}
-				const aclMapping: Record<string, S3Acl> = {
-					PUBLIC_READ: S3Acl.PublicRead,
-					PRIVATE: S3Acl.Private,
-					NONE: S3Acl.None,
-				}
-				const acl: S3Acl | undefined = args.acl ? aclMapping[args.acl] || undefined : undefined
-				return s3.getSignedUploadUrl(args.contentType, verifier, acl, args.expiration, args.prefix)
+				return s3.getSignedUploadUrl({
+					acl: args.input?.acl ?? args.acl ?? null,
+					contentDisposition: args.input?.contentDisposition ?? null,
+					contentType: args.input?.contentType ?? args.contentType ?? null,
+					expiration: args.input?.expiration ?? args.expiration ?? null,
+					extension: args.input?.extension ?? null,
+					fileName: args.input?.fileName ?? null,
+					prefix: args.input?.prefix ?? args.prefix ?? null,
+					suffix: args.input?.suffix ?? null,
+					size: args.input?.size ?? null,
+				})
 			},
 		}
 	}

package/src/S3SchemaTypes.ts

@@ -0,0 +1,89 @@
+import {
+	GraphQLEnumType,
+	GraphQLInputObjectType,
+	GraphQLInt,
+	GraphQLList,
+	GraphQLNonNull,
+	GraphQLObjectType,
+	GraphQLString,
+} from 'graphql'
+
+export const S3Header = new GraphQLObjectType({
+	name: 'S3Header',
+	fields: {
+		key: { type: new GraphQLNonNull(GraphQLString) },
+		value: { type: new GraphQLNonNull(GraphQLString) },
+	},
+})
+
+export const S3ContentDisposition = new GraphQLEnumType({
+	name: 'S33ContentDisposition', values: {
+		ATTACHMENT: {},
+		INLINE: {},
+	},
+})
+export type S3ContentDisposition = 'ATTACHMENT' | 'INLINE'
+
+export const S3SignedRead = new GraphQLObjectType({
+	name: 'S3SignedRead',
+	fields: {
+		url: { type: new GraphQLNonNull(GraphQLString) },
+		headers: {
+			type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(S3Header))),
+		},
+		method: { type: new GraphQLNonNull(GraphQLString) },
+		objectKey: { type: new GraphQLNonNull(GraphQLString) },
+		bucket: { type: new GraphQLNonNull(GraphQLString) },
+	},
+})
+
+export const S3SignedUpload = new GraphQLObjectType({
+	name: 'S3SignedUpload',
+	fields: {
+		url: { type: new GraphQLNonNull(GraphQLString) },
+		headers: {
+			type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(S3Header))),
+		},
+		method: { type: new GraphQLNonNull(GraphQLString) },
+		objectKey: { type: new GraphQLNonNull(GraphQLString) },
+		bucket: { type: new GraphQLNonNull(GraphQLString) },
+		publicUrl: { type: new GraphQLNonNull(GraphQLString) },
+	},
+})
+
+export const S3Acl = new GraphQLEnumType({
+	name: 'S3Acl',
+	values: {
+		PUBLIC_READ: {},
+		PRIVATE: {},
+		NONE: {},
+	},
+})
+
+export type S3Acl = 'PUBLIC_READ' | 'PRIVATE' | 'NONE'
+
+export const S3GenerateSignedUploadInput = new GraphQLInputObjectType({
+	name: 'S3GenerateSignedUploadInput',
+	fields: {
+		contentType: { type: GraphQLString },
+		extension: { type: GraphQLString, description: 'If not provided, extension is detected from a content-type.' },
+		expiration: { type: GraphQLInt, description: 'Signed URL expiration.' },
+		size: { type: GraphQLInt, description: 'Uploaded file size. Required when you enable ACL size limits.' },
+		prefix: { type: GraphQLString, description: 'Can be used as a "directory".' },
+		suffix: { type: GraphQLString, description: 'Suffix after generated id and before the extension.' },
+		fileName: { type: GraphQLString, description: 'This only affects Content-disposition header. Does not affect actual object key.' },
+		contentDisposition: { type: S3ContentDisposition },
+		acl: { type: S3Acl, description: 'If not supported by S3 provider, an error is thrown.' },
+	},
+})
+export interface S3GenerateSignedUploadInput {
+	contentType: null | string
+	extension: null | string
+	expiration: null | number
+	size: null | number
+	prefix: null | string
+	suffix: null | string
+	fileName: null | string
+	contentDisposition: null | S3ContentDisposition
+	acl: null | S3Acl
+}

package/src/S3Service.ts

@@ -1,15 +1,10 @@
-import { extension } from 'mime-types'
+import { extension as resolveExtension } from 'mime-types'
 import { resolveS3PublicBaseUrl, S3Config } from './Config'
-import { ObjectKeyVerifier } from './ObjectKeyVerifier'
-import { ForbiddenError } from '@contember/graphql-utils'
+import { ForbiddenError, UserInputError } from '@contember/graphql-utils'
 import { Providers } from '@contember/engine-plugins'
 import { S3Signer } from './S3Signer'
-
-export enum S3Acl {
-	None = 'none',
-	PublicRead = 'public-read',
-	Private = 'private',
-}
+import { S3GenerateSignedUploadInput } from './S3SchemaTypes'
+import { S3ObjectAuthorizator } from './S3ObjectAuthorizator'
 
 type SignedReadUrl = {
 	url: string
@@ -34,67 +29,79 @@ export class S3Service {
 
 	private readonly signer: S3Signer
 
-	constructor(public readonly config: S3Config, private readonly providers: Providers) {
+	constructor(
+		public readonly config: S3Config,
+		private readonly providers: Pick<Providers, 'uuid' | 'now'>,
+		private readonly authorizator: S3ObjectAuthorizator,
+	) {
 		this.publicBaseUrl = resolveS3PublicBaseUrl(config)
 		this.signer = new S3Signer(config, providers)
 	}
 
 	public getSignedUploadUrl(
-		contentType: string,
-		verifyKey: ObjectKeyVerifier,
-		acl?: S3Acl,
-		expiration?: number,
-		prefix?: string,
+		{ acl, contentDisposition, contentType, expiration, prefix, suffix, fileName, extension, size }: S3GenerateSignedUploadInput,
 	): SignedUploadUrl {
-		const ext = extension(contentType) || 'bin'
+		const ext = extension ?? ((contentType ? resolveExtension(contentType) : null) || 'bin')
 		const id = this.providers.uuid()
-		const localObjectKey = (prefix ? prefix + '/' : '') + `${id}.${ext}`
-		verifyKey(localObjectKey)
+		const localObjectKey = (prefix ? prefix + '/' : '') + `${id}${suffix ?? ''}.${ext}`
+		this.authorizator.verifyUploadAccess({ key: localObjectKey, size })
+
 		const objectKey = (this.config.prefix ? this.config.prefix + '/' : '') + localObjectKey
 
 		const bucket = this.config.bucket
 		if (acl && this.config.noAcl) {
-			throw new Error('ACL is not supported')
+			throw new UserInputError('ACL is not supported')
+		}
+
+		const headers: Record<string, string> = {
+			'Cache-Control': 'immutable',
+		}
+		if (contentType) {
+			headers['Content-Type'] = contentType
+		}
+
+		if (!this.config.noAcl && acl !== 'NONE') {
+			const mapping = { PUBLIC_READ: 'public-read', PRIVATE: 'private' }
+			headers['x-amz-acl'] = mapping[acl ?? 'PUBLIC_READ']
+		}
+		if (fileName || contentDisposition) {
+			let contentDispositionHeader = contentDisposition?.toLowerCase() ?? 'inline'
+			if (fileName) {
+				contentDispositionHeader += `; filename*=UTF-8''${encodeURIComponent(fileName)}`
+			}
+			headers['Content-Disposition'] = contentDispositionHeader
+		}
+		const headersToSend = Object.entries(headers).map(([key, value]) => ({ key, value }))
+
+		// intentionally not sending following headers
+		if (size) {
+			headers['Content-Length'] = String(size)
 		}
 
-		const aclValue = this.config.noAcl || acl === S3Acl.None ? undefined : acl || S3Acl.PublicRead
 		const url = this.signer.sign({
 			action: 'upload',
-			expiration: expiration || 3600,
+			expiration: expiration ?? 3600,
 			key: objectKey,
-			headers: {
-				'Content-Type': contentType,
-				'Cache-Control': 'immutable',
-				...(aclValue ? { 'x-amz-acl': aclValue } : {}),
-			},
+			headers: { ...headers },
 		})
+
 		const publicUrl = this.formatPublicUrl(objectKey)
 		return {
 			bucket,
 			objectKey,
 			url,
 			publicUrl,
-			headers: [
-				{
-					key: 'Content-Type',
-					value: contentType,
-				},
-				{
-					key: 'Cache-Control',
-					value: 'immutable',
-				},
-				...(aclValue ? [{ key: 'X-Amz-Acl', value: aclValue }] : []),
-			],
+			headers: headersToSend,
 			method: 'PUT',
 		}
 	}
 
-	public getSignedReadUrl(objectKey: string, verifyKey: ObjectKeyVerifier, expiration?: number): SignedReadUrl {
+	public getSignedReadUrl({ objectKey, expiration }: { objectKey: string; expiration: number | null}): SignedReadUrl {
 		const bucket = this.config.bucket
 
 		const publicPrefix = this.formatPublicUrl('')
 		if (objectKey.startsWith(publicPrefix)) {
-			objectKey = objectKey.substr(publicPrefix.length)
+			objectKey = objectKey.substring(publicPrefix.length)
 		}
 		if (this.config.prefix && !objectKey.startsWith(this.config.prefix)) {
 			throw new ForbiddenError(
@@ -102,14 +109,15 @@ export class S3Service {
 			)
 		}
 		const localObjectKey = this.config.prefix ? objectKey.substring(this.config.prefix.length + 1) : objectKey
-		verifyKey(localObjectKey)
+		this.authorizator.verifyReadAccess({ key: localObjectKey })
 
 		const url = this.signer.sign({
 			action: 'read',
-			expiration: expiration || 3600,
+			expiration: expiration ?? 3600,
 			key: objectKey,
 			headers: {},
 		})
+
 		return {
 			bucket,
 			objectKey,
@@ -125,7 +133,7 @@ export class S3Service {
 }
 
 export class S3ServiceFactory {
-	public create(config: S3Config, providers: Providers) {
-		return new S3Service(config, providers)
+	public create(config: S3Config, providers: Providers, authorizator: S3ObjectAuthorizator) {
+		return new S3Service(config, providers, authorizator)
 	}
 }

package/src/S3Signer.ts

@@ -14,7 +14,7 @@ const hmac = (secret: BinaryLike, data: BinaryLike) => createHmac('sha256', secr
 
 const hash = (data: BinaryLike) => createHash('sha256').update(data).digest('hex')
 
-const unsignableHeaders = ['authorization', 'content-type', 'content-length', 'user-agent', 'expect', 'x-amzn-trace-id']
+const unsignableHeaders = ['authorization', 'user-agent', 'content-type', 'expect', 'x-amzn-trace-id']
 
 const sortMap = <T extends Record<string, any>>(input: T): T => {
 	return Object.fromEntries(Object.entries(input).sort((a, b) => (a[0] < b[0] ? -1 : 1))) as T
@@ -22,7 +22,7 @@ const sortMap = <T extends Record<string, any>>(input: T): T => {
 export class S3Signer {
 	private region: string
 
-	constructor(private readonly config: S3Config, private readonly providers: Providers) {
+	constructor(private readonly config: S3Config, private readonly providers: Pick<Providers, 'now'>) {
 		this.region = config.region || 'eu-west-1'
 	}
 

package/src/index.ts

@@ -1,23 +1,25 @@
-import { Plugin, ProjectContainer } from '@contember/engine-plugins'
+import { Plugin, SchemaContributorArgs } from '@contember/engine-plugins'
 import { S3ConfigProcessor } from './S3ConfigProcessor'
 import { S3SchemaContributor } from './S3SchemaContributor'
 import { S3ServiceFactory } from './S3Service'
-import { ProjectWithS3Config } from './Config'
+import { Project3Config } from './Config'
 
+export * from './S3ObjectAuthorizator'
 export * from './S3SchemaContributor'
 export * from './S3Service'
 
-export default class S3 implements Plugin<ProjectWithS3Config> {
+export default class S3 implements Plugin<Project3Config> {
+	name = 'contember/s3'
+
 	getConfigProcessor() {
 		return new S3ConfigProcessor()
 	}
 
-	getSchemaContributor(container: ProjectContainer<ProjectWithS3Config>) {
-		const projectConfig = container.project
-		if (!projectConfig.s3) {
+	getSchemaContributor({ project, providers }: SchemaContributorArgs<Project3Config>) {
+		if (!project.s3) {
 			return undefined
 		}
 		const s3ServiceFactory = new S3ServiceFactory()
-		return new S3SchemaContributor(projectConfig.s3, s3ServiceFactory, container.providers)
+		return new S3SchemaContributor(project.s3, s3ServiceFactory, providers)
 	}
 }

package/src/tsconfig.json

@@ -5,14 +5,8 @@
 		"outDir": "../dist/src"
 	},
 	"references": [
-		{
-			"path": "../../typesafe/src"
-		},
-		{
-			"path": "../../engine-plugins/src"
-		},
-		{
-			"path": "../../graphql-utils/src"
-		}
+		{ "path": "../../typesafe/src" },
+		{ "path": "../../engine-plugins/src" },
+		{ "path": "../../graphql-utils/src" }
 	]
 }