@contember/client 1.0.0-rc.0 → 1.0.0-rc.11

package/src/content/index.ts

@@ -0,0 +1,4 @@
+export * from './upload'
+export * from './params'
+
+export * from './formatContentApiRelativeUrl'

package/src/content/params/index.ts

@@ -0,0 +1 @@
+export * from './whereToFilter'

package/src/content/params/whereToFilter.ts

@@ -0,0 +1,19 @@
+import type { Input } from '@contember/schema'
+import { GraphQlLiteral } from '../../graphQlBuilder'
+
+export const whereToFilter = (
+	by: Input.UniqueWhere<GraphQlLiteral>,
+): Input.Where<Input.Condition<Input.ColumnValue<GraphQlLiteral>>> => {
+	const where: Input.Where<Input.Condition<Input.ColumnValue<GraphQlLiteral>>> = {}
+	for (const key in by) {
+		const value = by[key]
+
+		if (value instanceof GraphQlLiteral || typeof value === 'string' || typeof value === 'number') {
+			where[key] = { eq: value }
+		} else {
+			where[key] = whereToFilter(value)
+		}
+	}
+
+	return where
+}

package/src/content/upload/FileUploadError.ts

@@ -0,0 +1,10 @@
+export interface FileUploadErrorOptions {
+	developerMessage?: string
+	endUserMessage?: string
+}
+
+export class FileUploadError extends Error {
+	public constructor(public readonly options: FileUploadErrorOptions = {}) {
+		super(options.developerMessage)
+	}
+}

package/src/content/upload/FileUploadProgress.ts

@@ -0,0 +1,3 @@
+export interface FileUploadProgress {
+	progress?: number
+}

package/src/content/upload/FileUploader.ts

@@ -0,0 +1,19 @@
+import type { GraphQlClient } from '../../graphQlClient'
+import type { FileUploadError } from './FileUploadError'
+import type { FileUploadProgress } from './FileUploadProgress'
+import type { UploadedFileMetadata } from './UploadedFileMetadata'
+
+export interface FileUploader<Result = any, Error extends FileUploadError = FileUploadError> {
+	upload: (
+		files: Map<File, UploadedFileMetadata>,
+		options: FileUploaderInitializeOptions<Result, Error>,
+	) => Promise<void>
+	destroy?: (files: Result[]) => Promise<void> // TODO Note that admin uploaders don'T actually invoke this yet.
+}
+
+export interface FileUploaderInitializeOptions<Result = any, Error extends FileUploadError = FileUploadError> {
+	contentApiClient: GraphQlClient
+	onSuccess: (result: Iterable<[File, Result]>) => void
+	onError: (error: Iterable<File | [File, Error]>) => void
+	onProgress: (progress: Iterable<[File, FileUploadProgress]>) => void
+}

package/src/content/upload/GenerateUploadUrlMutationBuilder.ts

@@ -0,0 +1,58 @@
+import { GraphQlLiteral, ObjectBuilder, QueryBuilder } from '../../graphQlBuilder'
+
+class GenerateUploadUrlMutationBuilder {
+	private static generateUploadUrlFields = new ObjectBuilder()
+		.name('generateUploadUrl')
+		.field('url')
+		.field('publicUrl')
+		.field('method')
+		.object('headers', builder => builder.field('key').field('value'))
+
+	public static buildQuery(parameters: GenerateUploadUrlMutationBuilder.MutationParameters): string {
+		return new QueryBuilder().mutation(builder => {
+			for (const alias in parameters) {
+				const fileParameters = parameters[alias]
+
+				builder = builder.object(
+					alias,
+					GenerateUploadUrlMutationBuilder.generateUploadUrlFields
+						.argument('contentType', fileParameters.contentType)
+						.argument('expiration', fileParameters.expiration)
+						.argument('prefix', fileParameters.prefix)
+						.argument('acl', fileParameters.acl),
+				)
+			}
+
+			return builder
+		})
+	}
+}
+
+namespace GenerateUploadUrlMutationBuilder {
+	export interface FileParameters {
+		contentType: string
+		expiration?: number
+		prefix?: string
+		acl?: GraphQlLiteral<'PUBLIC_READ' | 'PRIVATE' | 'NONE'>
+	}
+
+	export interface MutationParameters {
+		[alias: string]: FileParameters
+	}
+
+	export interface ResponseBody {
+		url: string
+		publicUrl: string
+		method: string
+		headers: Array<{
+			key: string
+			value: string
+		}>
+	}
+
+	export interface MutationResponse {
+		[alias: string]: ResponseBody
+	}
+}
+
+export { GenerateUploadUrlMutationBuilder }

package/src/content/upload/S3FileUploader.ts

@@ -0,0 +1,121 @@
+import { readFileAsArrayBuffer } from '../../utils'
+import type { FileUploader, FileUploaderInitializeOptions } from './FileUploader'
+import { GenerateUploadUrlMutationBuilder } from './GenerateUploadUrlMutationBuilder'
+import type { UploadedFileMetadata } from './UploadedFileMetadata'
+
+interface S3UploadState {
+	request?: XMLHttpRequest
+	alias: number
+}
+
+class S3FileUploader implements FileUploader<S3FileUploader.SuccessMetadata> {
+	private readonly uploadState: WeakMap<File, S3UploadState>
+
+	public constructor(public readonly options: S3FileUploader.Options = {}) {
+		this.uploadState = new WeakMap()
+	}
+
+	private generateNewAlias = (() => {
+		let alias = 1
+		return () => alias++
+	})()
+
+	private static formatFullAlias(alias: number) {
+		return `file${alias}`
+	}
+
+	public async upload(
+		files: Map<File, UploadedFileMetadata>,
+		{ contentApiClient, onSuccess, onError, onProgress }: FileUploaderInitializeOptions,
+	) {
+		const parameters: GenerateUploadUrlMutationBuilder.MutationParameters = {}
+
+		for (const [file, metadata] of files) {
+			if (this.uploadState.has(file)) {
+				const uploadState = this.uploadState.get(file)!
+				uploadState.request?.abort()
+			}
+
+			const alias = this.generateNewAlias()
+			this.uploadState.set(file, {
+				alias,
+			})
+
+			const uploadOptions = this.options.getUploadOptions?.(file)
+
+			parameters[S3FileUploader.formatFullAlias(alias)] = {
+				contentType: file.type,
+				prefix: uploadOptions?.filePrefix,
+				expiration: uploadOptions?.fileExpiration,
+				acl: uploadOptions?.fileAcl,
+			}
+
+			metadata.abortSignal.addEventListener('abort', () => {
+				this.uploadState.get(file)?.request?.abort()
+			})
+		}
+
+		const mutation = GenerateUploadUrlMutationBuilder.buildQuery(parameters)
+		try {
+			const response = await contentApiClient.sendRequest(mutation)
+			const responseData: GenerateUploadUrlMutationBuilder.MutationResponse = response.data
+
+			for (const [file] of files) {
+				const fileState = this.uploadState.get(file)!
+				const datumBody = responseData[S3FileUploader.formatFullAlias(fileState.alias)]
+				const uploadRequestBody = await readFileAsArrayBuffer(file)
+				const xhr = new XMLHttpRequest()
+
+				fileState.request = xhr
+
+				xhr.open(datumBody.method, datumBody.url)
+
+				for (const header of datumBody.headers) {
+					xhr.setRequestHeader(header.key, header.value)
+				}
+				xhr.addEventListener('load', () => {
+					const successMetadata: S3FileUploader.SuccessMetadata = {
+						fileUrl: datumBody.publicUrl,
+					}
+					onSuccess([[file, successMetadata]])
+				})
+				onError &&
+					xhr.addEventListener('error', e => {
+						onError([file])
+					})
+				onProgress &&
+					xhr.upload?.addEventListener('progress', e => {
+						onProgress([
+							[
+								file,
+								{
+									progress: e.loaded / e.total,
+								},
+							],
+						])
+					})
+				xhr.send(uploadRequestBody)
+			}
+		} catch (error) {
+			onError(Array.from(files).map(([file]) => [file, error]))
+		}
+	}
+}
+
+namespace S3FileUploader {
+	export interface SuccessMetadata {
+		fileUrl: string
+	}
+
+	export interface Options {
+		getUploadOptions?: (file: File) => S3UploadOptions
+	}
+
+	export interface S3UploadOptions {
+		fileExpiration?: GenerateUploadUrlMutationBuilder.FileParameters['expiration']
+		filePrefix?: GenerateUploadUrlMutationBuilder.FileParameters['prefix']
+		fileAcl?: GenerateUploadUrlMutationBuilder.FileParameters['acl']
+	}
+}
+
+export { S3FileUploader }

package/src/content/upload/SwitchFileUploader.ts

@@ -0,0 +1,40 @@
+import type { FileUploader, FileUploaderInitializeOptions } from './FileUploader'
+import type { UploadedFileMetadata } from './UploadedFileMetadata'
+
+class SwitchFileUploader implements FileUploader {
+	public constructor(private readonly subUploaders: SwitchFileUploader.SubUploaders) {}
+
+	public async upload(files: Map<File, UploadedFileMetadata>, options: FileUploaderInitializeOptions) {
+		const fileKinds: Map<FileUploader, Map<File, UploadedFileMetadata>> = new Map()
+		const unhandledFiles: Array<[File, any]> = []
+
+		fileLoop: for (const [file, metadata] of files) {
+			for (const [predicate, uploader] of this.subUploaders) {
+				if (predicate(file)) {
+					let nestedMap = fileKinds.get(uploader)
+					if (nestedMap === undefined) {
+						fileKinds.set(uploader, (nestedMap = new Map()))
+					}
+					nestedMap.set(file, metadata)
+					continue fileLoop
+				}
+			}
+			unhandledFiles.push([file, undefined])
+		}
+
+		if (unhandledFiles.length && options.onError) {
+			options.onError(unhandledFiles)
+		}
+
+		for (const [uploader, files] of fileKinds) {
+			uploader.upload(files, options) // Deliberately no await
+		}
+	}
+}
+
+namespace SwitchFileUploader {
+	export type FilePredicate = (file: File) => boolean
+	export type SubUploaders = Iterable<[FilePredicate, FileUploader]>
+}
+
+export { SwitchFileUploader }

package/src/content/upload/UploadedFileMetadata.ts

@@ -0,0 +1,3 @@
+export interface UploadedFileMetadata {
+	abortSignal: AbortSignal
+}

package/src/content/upload/index.ts

@@ -0,0 +1,7 @@
+export * from './FileUploader'
+export * from './FileUploadError'
+export * from './FileUploadProgress'
+export * from './GenerateUploadUrlMutationBuilder'
+export * from './UploadedFileMetadata'
+export * from './S3FileUploader'
+export * from './UploadedFileMetadata'

package/src/crudQueryBuilder/CrudQueryBuilder.ts

@@ -0,0 +1,160 @@
+import { ObjectBuilder, QueryBuilder, RootObjectBuilder } from '../graphQlBuilder'
+import { isEmptyObject } from '../utils'
+import { CrudQueryBuilderError } from './CrudQueryBuilderError'
+import { ReadBuilder } from './ReadBuilder'
+import type {
+	CreateMutationArguments,
+	CreateMutationFields,
+	DeleteMutationArguments,
+	DeleteMutationFields,
+	GetQueryArguments,
+	ListQueryArguments,
+	Mutations,
+	PaginateQueryArguments,
+	Queries,
+	UpdateMutationArguments,
+	UpdateMutationFields,
+	WriteOperation,
+} from './types'
+import { WriteBuilder } from './WriteBuilder'
+
+export class CrudQueryBuilder {
+	constructor(
+		private type: undefined | 'query' | 'mutation' = undefined,
+		private rootObjectBuilder: RootObjectBuilder = new RootObjectBuilder(),
+	) {}
+
+	public fragment(name: string, typeName: string, query: ReadBuilder.BuilderFactory<never>): CrudQueryBuilder {
+		const readBuilder = ReadBuilder.instantiateFromFactory(query)
+		const objectBuilder = readBuilder.objectBuilder.name(typeName)
+
+		return new CrudQueryBuilder(this.type, this.rootObjectBuilder.fragment(name, objectBuilder))
+	}
+
+	public list(
+		name: string,
+		query: ReadBuilder.BuilderFactory<ListQueryArguments>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Mutations> {
+		if (this.type === 'mutation') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `list${name}`
+		query = ReadBuilder.instantiateFromFactory(query)
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('query', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public paginate(
+		name: string,
+		query: ReadBuilder.BuilderFactory<PaginateQueryArguments>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Mutations> {
+		if (this.type === 'mutation') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `paginate${name}`
+		query = ReadBuilder.instantiateFromFactory(query)
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('query', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public get(
+		name: string,
+		query: ReadBuilder.BuilderFactory<GetQueryArguments>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Mutations> {
+		if (this.type === 'mutation') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `get${name}`
+		query = ReadBuilder.instantiateFromFactory(query)
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('query', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public update(
+		name: string,
+		query: WriteBuilder.BuilderFactory<UpdateMutationArguments, UpdateMutationFields, WriteOperation.Update>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Queries> {
+		if (this.type === 'query') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `update${name}`
+		query = WriteBuilder.instantiateFromFactory(query)
+
+		if (isEmptyObject(query.objectBuilder.args.data)) {
+			return this
+		}
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('mutation', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public create(
+		name: string,
+		query: WriteBuilder.BuilderFactory<CreateMutationArguments, CreateMutationFields, WriteOperation.Create>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Queries> {
+		if (this.type === 'query') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `create${name}`
+		query = WriteBuilder.instantiateFromFactory(query)
+
+		if (isEmptyObject(query.objectBuilder.args.data)) {
+			return this
+		}
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('mutation', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public delete(
+		name: string,
+		query: WriteBuilder.BuilderFactory<DeleteMutationArguments, DeleteMutationFields, WriteOperation.Delete>,
+		alias?: string,
+	): Omit<CrudQueryBuilder, Queries> {
+		if (this.type === 'query') {
+			throw new CrudQueryBuilderError('Cannot combine queries and mutations')
+		}
+		name = `delete${name}`
+		query = WriteBuilder.instantiateFromFactory(query)
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, query.objectBuilder.name(name)] : [name, query.objectBuilder]
+
+		return new CrudQueryBuilder('mutation', this.rootObjectBuilder.object(objectName, objectBuilder))
+	}
+
+	public inTransaction(alias: string = 'transaction', options: { deferForeignKeyConstraints?: boolean } = {}): CrudQueryBuilder {
+		const objectBuilder = new ObjectBuilder(undefined, { ...this.rootObjectBuilder.objects }, { options }, undefined, undefined, 'transaction')
+		return new CrudQueryBuilder(this.type, new RootObjectBuilder({ [alias]: objectBuilder }, this.rootObjectBuilder.fragmentDefinitions))
+	}
+
+	getGql(): string {
+		const builder = new QueryBuilder()
+		switch (this.type) {
+			case 'mutation':
+				return builder.mutation(this.rootObjectBuilder)
+			case 'query':
+				return builder.query(this.rootObjectBuilder)
+			default:
+				throw new CrudQueryBuilderError(`Invalid type ${this.type}`)
+		}
+	}
+}

package/src/crudQueryBuilder/CrudQueryBuilderError.ts

@@ -0,0 +1 @@
+export class CrudQueryBuilderError extends Error {}

package/src/crudQueryBuilder/ErrorsRelationBuilder.ts

@@ -0,0 +1,17 @@
+import type { ObjectBuilder } from '../graphQlBuilder'
+
+export class ErrorsRelationBuilder {
+	public static errorsRelation(objectBuilder: ObjectBuilder): ObjectBuilder {
+		return objectBuilder.object('errors', builder =>
+			builder
+				.field('type')
+				.field('message')
+				.object('path', builder =>
+					builder
+						.field('__typename')
+						.inlineFragment('_FieldPathFragment', builder => builder.field('field'))
+						.inlineFragment('_IndexPathFragment', builder => builder.field('index').field('alias')),
+				),
+		)
+	}
+}

package/src/crudQueryBuilder/ReadBuilder.ts

@@ -0,0 +1,106 @@
+import type { Input } from '@contember/schema'
+import { GraphQlLiteral, ObjectBuilder } from '../graphQlBuilder'
+import type { HasManyArguments, HasOneArguments, OrderDirection, ReadArguments, ReductionArguments } from './types'
+
+class ReadBuilder<AllowedArgs extends ReadArguments = ReadArguments> {
+	protected constructor(public readonly objectBuilder: ObjectBuilder = new ObjectBuilder()) {}
+
+	public static instantiate<AllowedArgs extends ReadArguments = ReadArguments>(
+		objectBuilder: ObjectBuilder = new ObjectBuilder(),
+	): ReadBuilder.Builder<AllowedArgs> {
+		return new ReadBuilder<AllowedArgs>(objectBuilder)
+	}
+
+	public static instantiateFromFactory<AllowedArgs extends ReadArguments>(
+		builder: ReadBuilder.BuilderFactory<AllowedArgs>,
+	): ReadBuilder.Builder<never> {
+		if (typeof builder === 'function') {
+			return builder(ReadBuilder.instantiate())
+		}
+		return builder
+	}
+
+	protected instantiate<AA extends ReadArguments = ReadArguments>(
+		objectBuilder: ObjectBuilder = new ObjectBuilder(),
+	): ReadBuilder.Builder<AA> {
+		return ReadBuilder.instantiate<AA>(objectBuilder)
+	}
+
+	public by(by: Input.UniqueWhere<GraphQlLiteral>) {
+		return this.instantiate<Exclude<AllowedArgs, 'by'>>(this.objectBuilder.argument('by', by))
+	}
+
+	public filter(where: Input.Where<Input.Condition<Input.ColumnValue<GraphQlLiteral>>>) {
+		return this.instantiate<Exclude<AllowedArgs, 'filter'>>(this.objectBuilder.argument('filter', where))
+	}
+
+	public orderBy(orderBy: Input.OrderBy<OrderDirection>[]) {
+		return this.instantiate<Exclude<AllowedArgs, 'orderBy'>>(this.objectBuilder.argument('orderBy', orderBy))
+	}
+
+	public offset(offset: number) {
+		return this.instantiate<Exclude<AllowedArgs, 'offset'>>(this.objectBuilder.argument('offset', offset))
+	}
+
+	public limit(limit: number) {
+		return this.instantiate<Exclude<AllowedArgs, 'limit'>>(this.objectBuilder.argument('limit', limit))
+	}
+
+	public skip(offset: number) {
+		return this.instantiate<Exclude<AllowedArgs, 'skip'>>(this.objectBuilder.argument('skip', offset))
+	}
+
+	public first(limit: number) {
+		return this.instantiate<Exclude<AllowedArgs, 'first'>>(this.objectBuilder.argument('first', limit))
+	}
+
+	public column(name: string) {
+		return this.instantiate<AllowedArgs>(this.objectBuilder.field(name))
+	}
+
+	public inlineFragment(typeName: string, builder: ReadBuilder.BuilderFactory<never>) {
+		builder = ReadBuilder.instantiateFromFactory(builder)
+		return this.instantiate<AllowedArgs>(this.objectBuilder.inlineFragment(typeName, builder.objectBuilder))
+	}
+
+	public applyFragment(fragmentName: string) {
+		return this.instantiate<AllowedArgs>(this.objectBuilder.applyFragment(fragmentName))
+	}
+
+	public reductionRelation(name: string, builder: ReadBuilder.BuilderFactory<ReductionArguments>, alias?: string) {
+		return this.relation(name, builder, alias)
+	}
+
+	public hasOneRelation(name: string, builder: ReadBuilder.BuilderFactory<HasOneArguments>, alias?: string) {
+		return this.relation(name, builder, alias)
+	}
+
+	public hasManyRelation(name: string, builder: ReadBuilder.BuilderFactory<HasManyArguments>, alias?: string) {
+		return this.relation(name, builder, alias)
+	}
+
+	public anyRelation(name: string, builder: ReadBuilder.BuilderFactory<never>, alias?: string) {
+		return this.relation(name, builder, alias)
+	}
+
+	protected relation<A extends ReadArguments>(name: string, builder: ReadBuilder.BuilderFactory<A>, alias?: string) {
+		builder = ReadBuilder.instantiateFromFactory(builder)
+
+		const [objectName, objectBuilder] =
+			typeof alias === 'string' ? [alias, builder.objectBuilder.name(name)] : [name, builder.objectBuilder]
+
+		return this.instantiate<AllowedArgs>(this.objectBuilder.object(objectName, objectBuilder))
+	}
+}
+
+namespace ReadBuilder {
+	export type Builder<AllowedArgs extends ReadArguments> = Omit<
+		ReadBuilder<AllowedArgs>,
+		Exclude<ReadArguments, AllowedArgs>
+	>
+	export type BuilderFactory<AllowedArgs extends ReadArguments> =
+		| Builder<never>
+		| ((builder: Builder<AllowedArgs>) => Builder<never>)
+}
+
+export { ReadBuilder }

package/src/crudQueryBuilder/ValidationRelationBuilder.ts

@@ -0,0 +1,18 @@
+import type { ObjectBuilder } from '../graphQlBuilder'
+
+export class ValidationRelationBuilder {
+	public static validationRelation(objectBuilder: ObjectBuilder): ObjectBuilder {
+		return objectBuilder.object('validation', builder =>
+			builder.field('valid').object('errors', builder =>
+				builder
+					.object('path', builder =>
+						builder
+							.field('__typename')
+							.inlineFragment('_FieldPathFragment', builder => builder.field('field'))
+							.inlineFragment('_IndexPathFragment', builder => builder.field('index').field('alias')),
+					)
+					.object('message', builder => builder.field('text')),
+			),
+		)
+	}
+}