@contember/client 1.2.5 → 1.3.0-alpha.10

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 }

package/src/crudQueryBuilder/WriteOneRelationBuilder.ts

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

package/src/graphQlBuilder/GraphQlBuilderError.ts

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

package/src/graphQlBuilder/ObjectBuilder.ts

@@ -1,87 +0,0 @@
-export class ObjectBuilder {
-	constructor(
-		public readonly fields: string[] = [],
-		public readonly objects: { [name: string]: ObjectBuilder } = {},
-		public readonly args: { [name: string]: any } = {},
-		public readonly fragmentApplications: string[] = [],
-		public readonly inlineFragments: { [typeName: string]: ObjectBuilder } = {},
-		public readonly objectName?: string,
-	) {}
-
-	public argument(name: string, value: any): ObjectBuilder {
-		return new ObjectBuilder(
-			this.fields,
-			this.objects,
-			{ ...this.args, [name]: value },
-			this.fragmentApplications,
-			this.inlineFragments,
-			this.objectName,
-		)
-	}
-
-	public name(name: string): ObjectBuilder {
-		return new ObjectBuilder(
-			this.fields,
-			this.objects,
-			this.args,
-			this.fragmentApplications,
-			this.inlineFragments,
-			name,
-		)
-	}
-
-	public field(name: string): ObjectBuilder {
-		return new ObjectBuilder(
-			[...this.fields, name],
-			this.objects,
-			this.args,
-			this.fragmentApplications,
-			this.inlineFragments,
-			this.objectName,
-		)
-	}
-
-	public object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): ObjectBuilder {
-		if (!(builder instanceof ObjectBuilder)) {
-			builder = builder(new ObjectBuilder())
-		}
-
-		return new ObjectBuilder(
-			this.fields,
-			{ ...this.objects, [name]: builder },
-			this.args,
-			this.fragmentApplications,
-			this.inlineFragments,
-			this.objectName,
-		)
-	}
-
-	public inlineFragment(
-		typeName: string,
-		builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder,
-	): ObjectBuilder {
-		if (!(builder instanceof ObjectBuilder)) {
-			builder = builder(new ObjectBuilder())
-		}
-
-		return new ObjectBuilder(
-			this.fields,
-			this.objects,
-			this.args,
-			this.fragmentApplications,
-			{ ...this.inlineFragments, [typeName]: builder },
-			this.objectName,
-		)
-	}
-
-	public applyFragment(fragmentName: string): ObjectBuilder {
-		return new ObjectBuilder(
-			this.fields,
-			this.objects,
-			this.args,
-			[...this.fragmentApplications, fragmentName],
-			this.inlineFragments,
-			this.objectName,
-		)
-	}
-}

package/src/graphQlBuilder/QueryCompiler.ts

@@ -1,115 +0,0 @@
-import { GraphQlLiteral } from './GraphQlLiteral'
-import type { ObjectBuilder } from './ObjectBuilder'
-import type { RootObjectBuilder } from './RootObjectBuilder'
-
-export class QueryCompiler {
-	constructor(private operation: 'query' | 'mutation', private builder: RootObjectBuilder) {}
-
-	public create(): string {
-		const rootObjects = this.formatRootObjects(this.builder.objects)
-		const fragmentDefinitions = this.formatFragmentDefinitions(this.builder.fragmentDefinitions)
-
-		return `${this.operation} {\n${rootObjects}\n}${fragmentDefinitions ? `\n${fragmentDefinitions}` : ''}`
-	}
-
-	private formatFragmentDefinitions(fragments: RootObjectBuilder['fragmentDefinitions']): string {
-		const lines: string[] = []
-
-		for (const name in fragments) {
-			const object = fragments[name]
-
-			lines.push(`fragment ${name} on ${object.objectName!} {`)
-			lines.push(...this.formatObjectBody(object))
-			lines.push('}')
-		}
-
-		return lines.join('\n')
-	}
-
-	private formatRootObjects(objects: RootObjectBuilder['objects']): string {
-		const lines: string[] = []
-
-		for (const alias in objects) {
-			lines.push(...this.formatObject(alias, objects[alias]).map(val => `\t${val}`))
-		}
-
-		return lines.join('\n')
-	}
-
-	private formatObject(alias: string, builder: ObjectBuilder): string[] {
-		const result = []
-
-		result.push(`${alias}${builder.objectName ? `: ${builder.objectName}` : ''}${this.formatArgs(builder.args, 0)} {`)
-
-		result.push(...this.formatObjectBody(builder))
-
-		result.push('}')
-
-		return result
-	}
-
-	private formatObjectBody(builder: ObjectBuilder): string[] {
-		const result = ['__typename']
-		for (const fieldName of builder.fields) {
-			result.push(fieldName)
-		}
-		for (const fragmentName of builder.fragmentApplications) {
-			result.push(`... ${fragmentName}`)
-		}
-		for (const typeName in builder.inlineFragments) {
-			const fragment = builder.inlineFragments[typeName]
-			result.push(`... on ${typeName} {`, ...this.formatObjectBody(fragment), '}')
-		}
-		for (const alias in builder.objects) {
-			result.push(...this.formatObject(alias, builder.objects[alias]))
-		}
-		return result.map(val => `\t${val}`)
-	}
-
-	private formatArgs(args: any, level: number): string {
-		if (args === null) {
-			return 'null'
-		}
-
-		if (typeof args === 'number') {
-			return args.toString()
-		}
-
-		if (typeof args === 'boolean') {
-			return args ? 'true' : 'false'
-		}
-		if (typeof args === 'string') {
-			return JSON.stringify(args)
-		}
-
-		if (Array.isArray(args)) {
-			const vals = args.map(val => this.formatArgs(val, level + 1))
-			return `[${vals.join(', ')}]`
-		}
-		if (args instanceof GraphQlLiteral) {
-			return args.value
-		}
-
-		if (typeof args === 'object') {
-			let result = ''
-			for (let key in args) {
-				const argValue = args[key]
-				if (argValue === undefined) {
-					continue
-				}
-				result += `${key}: ${this.formatArgs(argValue, level + 1)}, `
-			}
-			if (result.length > 0) {
-				result = result.substring(0, result.length - 2)
-			}
-			if (level > 0) {
-				return `{${result}}`
-			} else if (result.length > 0) {
-				return `(${result})`
-			}
-			return ''
-		}
-
-		throw new Error(typeof args)
-	}
-}

package/src/graphQlBuilder/RootObjectBuilder.ts

@@ -1,36 +0,0 @@
-import { isEmptyObject } from '../utils'
-import { GraphQlBuilderError } from './GraphQlBuilderError'
-import { ObjectBuilder } from './ObjectBuilder'
-
-export class RootObjectBuilder {
-	constructor(
-		public readonly objects: { [name: string]: ObjectBuilder } = {},
-		public readonly fragmentDefinitions: { [name: string]: ObjectBuilder } = {},
-	) {}
-
-	public fragment(
-		name: string,
-		builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder,
-	): RootObjectBuilder {
-		if (!(builder instanceof ObjectBuilder)) {
-			builder = builder(new ObjectBuilder())
-		}
-
-		if (!isEmptyObject(builder.args)) {
-			throw new GraphQlBuilderError(`Cannot supply args to Graph QL fragments!`)
-		}
-		if (!builder.objectName) {
-			throw new GraphQlBuilderError(`Object names are mandatory for Graph QL fragments!`)
-		}
-
-		return new RootObjectBuilder(this.objects, { ...this.fragmentDefinitions, [name]: builder })
-	}
-
-	public object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): RootObjectBuilder {
-		if (!(builder instanceof ObjectBuilder)) {
-			builder = builder(new ObjectBuilder())
-		}
-
-		return new RootObjectBuilder({ ...this.objects, [name]: builder }, this.fragmentDefinitions)
-	}
-}