@contember/client 1.2.6 → 1.3.0-alpha.3

package/src/crudQueryBuilder/CrudQueryBuilder.ts

@@ -1,168 +0,0 @@
-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(
-			['ok', 'errorMessage'],
-			{ ...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

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

package/src/crudQueryBuilder/ErrorsRelationBuilder.ts

@@ -1,16 +0,0 @@
-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
-						.inlineFragment('_FieldPathFragment', builder => builder.field('field'))
-						.inlineFragment('_IndexPathFragment', builder => builder.field('index').field('alias')),
-				),
-		)
-	}
-}

package/src/crudQueryBuilder/ReadBuilder.ts

@@ -1,106 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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
-							.inlineFragment('_FieldPathFragment', builder => builder.field('field'))
-							.inlineFragment('_IndexPathFragment', builder => builder.field('index').field('alias')),
-					)
-					.object('message', builder => builder.field('text')),
-			),
-		)
-	}
-}

package/src/crudQueryBuilder/WriteBuilder.ts

@@ -1,79 +0,0 @@
-import type { Input } from '@contember/schema'
-import { GraphQlLiteral, ObjectBuilder } from '../graphQlBuilder'
-import { ErrorsRelationBuilder } from './ErrorsRelationBuilder'
-import { ReadBuilder } from './ReadBuilder'
-import type { WriteArguments, WriteFields, WriteOperation } from './types'
-import { ValidationRelationBuilder } from './ValidationRelationBuilder'
-import { WriteDataBuilder } from './WriteDataBuilder'
-
-class WriteBuilder<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> {
-	protected constructor(public readonly objectBuilder: ObjectBuilder = new ObjectBuilder()) {}
-
-	public static instantiate<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation>(
-		objectBuilder: ObjectBuilder = new ObjectBuilder(),
-	): WriteBuilder.Builder<AA, AF, Op> {
-		return new WriteBuilder<AA, AF, Op>(objectBuilder)
-	}
-
-	public static instantiateFromFactory<
-		AA extends WriteArguments,
-		AF extends WriteFields,
-		Op extends WriteOperation.Operation,
-	>(builder: WriteBuilder.BuilderFactory<AA, AF, Op>): WriteBuilder.Builder<never, never, Op> {
-		if (typeof builder === 'function') {
-			return builder(WriteBuilder.instantiate())
-		}
-		return builder
-	}
-
-	public data<SubOp extends Op & WriteOperation.ContentfulOperation>(data: WriteDataBuilder.DataLike<SubOp>) {
-		const resolvedData = WriteDataBuilder.resolveData(data)
-		return WriteBuilder.instantiate<Exclude<AA, 'data'>, AF, Op>(
-			resolvedData === undefined ? this.objectBuilder : this.objectBuilder.argument('data', resolvedData),
-		)
-	}
-
-	public by(by: Input.UniqueWhere<GraphQlLiteral>) {
-		return WriteBuilder.instantiate<Exclude<AA, 'by'>, AF, Op>(this.objectBuilder.argument('by', by))
-	}
-
-	public ok() {
-		return WriteBuilder.instantiate<AA, Exclude<AF, 'ok'>, Op>(this.objectBuilder.field('ok'))
-	}
-
-	public errorMessage() {
-		return WriteBuilder.instantiate<AA, Exclude<AF, 'errorMessage'>, Op>(this.objectBuilder.field('errorMessage'))
-	}
-
-	public validation() {
-		return WriteBuilder.instantiate<AA, Exclude<AF, 'validation'>, Op>(
-			ValidationRelationBuilder.validationRelation(this.objectBuilder),
-		)
-	}
-
-	public errors() {
-		return WriteBuilder.instantiate<AA, Exclude<AF, 'errors'>, Op>(
-			ErrorsRelationBuilder.errorsRelation(this.objectBuilder),
-		)
-	}
-
-	public node(builder: ReadBuilder.BuilderFactory<never>) {
-		const readBuilder = ReadBuilder.instantiateFromFactory(builder)
-		return WriteBuilder.instantiate<AA, Exclude<AF, 'node'>, Op>(
-			this.objectBuilder.object('node', readBuilder.objectBuilder),
-		)
-	}
-}
-
-namespace WriteBuilder {
-	export type Builder<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> = Omit<
-		Omit<WriteBuilder<AA, AF, Op>, Exclude<WriteArguments, AA>>,
-		Exclude<WriteFields, AF>
-	>
-
-	export type BuilderFactory<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> =
-		| Builder<never, never, Op>
-		| ((builder: Builder<AA, AF, Op>) => Builder<never, never, Op>)
-}
-
-export { WriteBuilder }

package/src/crudQueryBuilder/WriteDataBuilder.ts

@@ -1,153 +0,0 @@
-import type { Input, Value } from '@contember/schema'
-import { GraphQlLiteral } from '../graphQlBuilder'
-import { isEmptyObject } from '../utils'
-import { CrudQueryBuilderError } from './CrudQueryBuilderError'
-import type { WriteOperation } from './types'
-import { WriteManyRelationBuilder } from './WriteManyRelationBuilder'
-import { WriteOneRelationBuilder } from './WriteOneRelationBuilder'
-
-class WriteDataBuilder<Op extends WriteOperation.ContentfulOperation> {
-	public readonly data: WriteDataBuilder.DataFormat[Op['op']]
-
-	public constructor(data?: WriteDataBuilder.DataFormat[Op['op']]) {
-		this.data = data || {}
-	}
-
-	public static resolveData<Op extends WriteOperation.ContentfulOperation>(
-		dataLike: WriteDataBuilder.DataLike<Op>,
-	): WriteDataBuilder.DataFormat[Op['op']] | undefined {
-		let resolvedData: WriteDataBuilder.DataFormat[Op['op']]
-
-		if (dataLike instanceof WriteDataBuilder) {
-			resolvedData = dataLike.data
-		} else if (typeof dataLike === 'function') {
-			resolvedData = dataLike(new WriteDataBuilder()).data
-		} else {
-			resolvedData = dataLike
-		}
-
-		if (isEmptyObject(resolvedData)) {
-			return undefined
-		}
-		return resolvedData
-	}
-
-	public set(fieldName: string, value: Input.ColumnValue<GraphQlLiteral>) {
-		return new WriteDataBuilder<Op>({ ...this.data, [fieldName]: value })
-	}
-
-	public many(fieldName: string, data: WriteManyRelationBuilder.BuilderFactory<Op>): WriteDataBuilder<Op> {
-		const resolvedData = WriteManyRelationBuilder.instantiateFromFactory(data).data
-		return resolvedData === undefined || resolvedData.length === 0
-			? this
-			: new WriteDataBuilder<Op>(this.mergeInFreshData(this.data, fieldName, resolvedData))
-	}
-
-	public one(fieldName: string, data: WriteOneRelationBuilder.BuilderFactory<Op>): WriteDataBuilder<Op> {
-		const resolvedData = WriteOneRelationBuilder.instantiateFromFactory(data).data
-		return resolvedData === undefined || isEmptyObject(resolvedData)
-			? this
-			: new WriteDataBuilder<Op>(this.mergeInFreshData(this.data, fieldName, resolvedData))
-	}
-
-	private mergeInFreshData(
-		original: WriteDataBuilder.DataFormat[Op['op']],
-		fieldName: string,
-		fresh: WriteManyRelationBuilder.DataFormat[Op['op']] | WriteOneRelationBuilder.DataFormat[Op['op']],
-	): WriteDataBuilder.DataFormat[Op['op']] {
-		if (fieldName in original) {
-			const existingValue = original[fieldName]
-			if (Array.isArray(existingValue)) {
-				if (Array.isArray(fresh)) {
-					return { ...original, [fieldName]: [...existingValue, ...fresh] }
-				}
-				throw new CrudQueryBuilderError(`Inconsistent data.`)
-			}
-			if (Array.isArray(fresh)) {
-				throw new CrudQueryBuilderError(`Inconsistent data.`)
-			}
-			return { ...original, [fieldName]: this.mergeUpdateOne(existingValue, fresh) }
-		}
-		return { ...original, [fieldName]: fresh }
-	}
-
-	private mergeUpdateOne(
-		original:
-			| Value.FieldValue<GraphQlLiteral>
-			| Input.CreateOneRelationInput<GraphQlLiteral>
-			| Input.UpdateOneRelationInput<GraphQlLiteral>,
-		fresh:
-			| Value.FieldValue<GraphQlLiteral>
-			| Input.CreateOneRelationInput<GraphQlLiteral>
-			| Input.UpdateOneRelationInput<GraphQlLiteral>,
-	):
-		| Value.FieldValue<GraphQlLiteral>
-		| Input.CreateOneRelationInput<GraphQlLiteral>
-		| Input.UpdateOneRelationInput<GraphQlLiteral> {
-		// TODO This implementation pretty bad but it will have to do for now.
-		if (original instanceof GraphQlLiteral) {
-			if (fresh instanceof GraphQlLiteral) {
-				if (original.value === fresh.value) {
-					return original
-				}
-			}
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-		if (fresh instanceof GraphQlLiteral) {
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-
-		if (Array.isArray(original)) {
-			if (Array.isArray(fresh)) {
-				return [...original, ...fresh]
-			}
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-		if (Array.isArray(fresh)) {
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-
-		if (original === null) {
-			if (fresh === null) {
-				return original
-			}
-		}
-		if (fresh === null) {
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-
-		if (typeof original === 'object') {
-			if (typeof fresh === 'object') {
-				const composite: any = { ...original }
-				for (const field in fresh) {
-					const fromFresh = (fresh as any)[field]
-					composite[field] = field in composite ? this.mergeUpdateOne(composite[field], fromFresh) : fromFresh
-				}
-				return composite
-			}
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-		if (typeof fresh === 'object') {
-			throw new CrudQueryBuilderError(`Inconsistent data.`)
-		}
-
-		if (original === fresh) {
-			return original
-		}
-		throw new CrudQueryBuilderError(`Inconsistent data.`)
-	}
-}
-
-namespace WriteDataBuilder {
-	export interface DataFormat {
-		create: Input.CreateDataInput<GraphQlLiteral>
-		update: Input.UpdateDataInput<GraphQlLiteral>
-	}
-
-	export type DataLike<Op extends WriteOperation.ContentfulOperation> =
-		| DataFormat[Op['op']]
-		| WriteDataBuilder<Op>
-		| ((builder: WriteDataBuilder<Op>) => WriteDataBuilder<Op>)
-}
-
-export { WriteDataBuilder }

package/src/crudQueryBuilder/WriteManyRelationBuilder.ts

@@ -1,141 +0,0 @@
-import type { Input } from '@contember/schema'
-import type { GraphQlLiteral } from '../graphQlBuilder'
-import type { WriteOperation, WriteRelationOps } from './types'
-import { WriteDataBuilder } from './WriteDataBuilder'
-
-class WriteManyRelationBuilder<
-	Op extends WriteOperation.ContentfulOperation,
-	Allowed extends WriteRelationOps[Op['op']],
-> {
-	private constructor(public readonly data: WriteManyRelationBuilder.DataFormat[Op['op']] = []) {}
-
-	public static instantiate<
-		Op extends WriteOperation.ContentfulOperation,
-		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
-	>(data: WriteManyRelationBuilder.DataFormat[Op['op']] = []): WriteManyRelationBuilder.Builder<Op, Allowed> {
-		return new WriteManyRelationBuilder<Op, Allowed>(data)
-	}
-
-	public static instantiateFromFactory<
-		Op extends WriteOperation.ContentfulOperation,
-		Allowed extends WriteRelationOps[Op['op']],
-	>(builder: WriteManyRelationBuilder.BuilderFactory<Op, Allowed>): WriteManyRelationBuilder.Builder<Op, never> {
-		if (typeof builder === 'function') {
-			return builder(WriteManyRelationBuilder.instantiate())
-		}
-		if ('data' in builder) {
-			return WriteManyRelationBuilder.instantiate(builder.data)
-		}
-		return WriteManyRelationBuilder.instantiate(builder)
-	}
-
-	public create(
-		data: WriteDataBuilder.DataLike<WriteOperation.Create>,
-		alias?: string,
-	): WriteManyRelationBuilder.Builder<Op> {
-		const resolvedData = WriteDataBuilder.resolveData(data)
-		return (
-			resolvedData === undefined
-				? this
-				: WriteManyRelationBuilder.instantiate<Op>([
-						...this.data,
-						this.withAlias({ create: resolvedData }, alias),
-				  ] as WriteManyRelationBuilder.DataFormat[WriteOperation.Create['op']])
-		) as WriteManyRelationBuilder.Builder<Op>
-	}
-
-	public connect(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string) {
-		return WriteManyRelationBuilder.instantiate<Op>([
-			...this.data,
-			this.withAlias({ connect: where }, alias),
-		] as WriteManyRelationBuilder.DataFormat[Op['op']])
-	}
-
-	public delete(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string) {
-		return WriteManyRelationBuilder.instantiate<WriteOperation.Update>([
-			...this.data,
-			this.withAlias({ delete: where }, alias),
-		])
-	}
-
-	public disconnect(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string) {
-		return WriteManyRelationBuilder.instantiate<WriteOperation.Update>([
-			...this.data,
-			this.withAlias({ disconnect: where }, alias),
-		])
-	}
-
-	public update(
-		where: Input.UniqueWhere<GraphQlLiteral>,
-		data: WriteDataBuilder.DataLike<WriteOperation.Update>,
-		alias?: string,
-	): WriteManyRelationBuilder.Builder<WriteOperation.Update> {
-		const resolvedData = WriteDataBuilder.resolveData(data)
-		return (
-			resolvedData === undefined
-				? this
-				: WriteManyRelationBuilder.instantiate<WriteOperation.Update>([
-						...this.data,
-						this.withAlias({ update: { by: where, data: resolvedData } }, alias),
-				  ])
-		) as WriteManyRelationBuilder.Builder<WriteOperation.Update>
-	}
-
-	public upsert(
-		where: Input.UniqueWhere<GraphQlLiteral>,
-		update: WriteDataBuilder.DataLike<WriteOperation.Update>,
-		create: WriteDataBuilder.DataLike<WriteOperation.Create>,
-		alias?: string,
-	): WriteManyRelationBuilder.Builder<WriteOperation.Update> {
-		const resolvedUpdate = WriteDataBuilder.resolveData(update)
-		const resolvedCreate = WriteDataBuilder.resolveData(create)
-		return (
-			resolvedUpdate === undefined && resolvedCreate === undefined
-				? this
-				: WriteManyRelationBuilder.instantiate<WriteOperation.Update>([
-						...this.data,
-						this.withAlias(
-							{
-								upsert: {
-									by: where,
-									update: resolvedUpdate || {},
-									create: resolvedCreate || {},
-								},
-							},
-							alias,
-						),
-				  ])
-		) as WriteManyRelationBuilder.Builder<WriteOperation.Update>
-	}
-
-	private withAlias<
-		D extends Input.CreateOneRelationInput<GraphQlLiteral> | Input.UpdateManyRelationInputItem<GraphQlLiteral>,
-	>(data: D, alias?: string): D {
-		if (alias !== undefined) {
-			data.alias = alias
-		}
-		return data
-	}
-}
-
-namespace WriteManyRelationBuilder {
-	export interface DataFormat {
-		create: Input.CreateManyRelationInput<GraphQlLiteral>
-		update: Input.UpdateManyRelationInput<GraphQlLiteral>
-	}
-
-	export type Builder<
-		Op extends WriteOperation.ContentfulOperation,
-		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
-	> = Omit<
-		WriteManyRelationBuilder<Op, Allowed>,
-		Exclude<WriteRelationOps[WriteOperation.ContentfulOperation['op']], Allowed>
-	>
-
-	export type BuilderFactory<
-		Op extends WriteOperation.ContentfulOperation,
-		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
-	> = DataFormat[Op['op']] | Builder<Op, never> | ((builder: Builder<Op, Allowed>) => Builder<Op, never>)
-}
-
-export { WriteManyRelationBuilder }