@contember/client 1.0.0-rc.2 → 1.0.0-rc.4

package/src/crudQueryBuilder/WriteDataBuilder.ts

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

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

@@ -0,0 +1,101 @@
+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/crudQueryBuilder/index.ts

@@ -0,0 +1,7 @@
+export * from './CrudQueryBuilder'
+export * from './ReadBuilder'
+export * from './types'
+export * from './WriteBuilder'
+export * from './WriteDataBuilder'
+export * from './WriteManyRelationBuilder'
+export * from './WriteOneRelationBuilder'

package/src/crudQueryBuilder/types.ts

@@ -0,0 +1,73 @@
+import type { GraphQlBuilder } from '../index'
+
+export type Mutations = 'create' | 'update' | 'delete'
+
+export type Queries = 'get' | 'list' | 'paginate'
+
+export type GetQueryArguments = 'by'
+
+export type ListQueryArguments = 'filter' | 'orderBy' | 'offset' | 'limit'
+
+export type PaginateQueryArguments = 'filter' | 'orderBy' | 'skip' | 'first'
+
+export type CreateMutationArguments = 'data'
+
+export type UpdateMutationArguments = 'data' | 'by'
+
+export type DeleteMutationArguments = 'by'
+
+export type ReductionArguments = 'filter' | 'by'
+
+export type HasOneArguments = 'filter'
+
+export type HasManyArguments = 'filter' | 'orderBy' | 'offset' | 'limit'
+
+export type UpdateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node'
+
+export type CreateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node'
+
+export type DeleteMutationFields = 'ok' | 'node' | 'errors' | 'errorMessage'
+
+export type WriteArguments = CreateMutationArguments | UpdateMutationArguments | DeleteMutationArguments
+
+export type WriteFields = UpdateMutationFields | CreateMutationFields
+
+export type ReadArguments =
+	| GetQueryArguments
+	| ListQueryArguments
+	| PaginateQueryArguments
+	| HasOneArguments
+	| HasManyArguments
+
+export interface WriteRelationOps {
+	create: 'create' | 'connect'
+	update: 'create' | 'connect' | 'delete' | 'disconnect' | 'update' | 'upsert'
+}
+
+export type OrderDirection = GraphQlBuilder.GraphQlLiteral<'asc'> | GraphQlBuilder.GraphQlLiteral<'desc'>
+
+// TODO Silly enums because TS does not support enum extension 🙄
+// https://github.com/Microsoft/TypeScript/issues/17592
+export namespace WriteOperation {
+	export interface Operation {
+		op: 'create' | 'update' | 'delete'
+	}
+	export abstract class Operation implements Operation {}
+
+	export interface ContentfulOperation {
+		op: 'create' | 'update'
+	}
+	export abstract class ContentfulOperation extends Operation implements ContentfulOperation {}
+
+	export class Update extends ContentfulOperation {
+		override readonly op = 'update' as const
+	}
+
+	export class Create extends ContentfulOperation {
+		override readonly op = 'create' as const
+	}
+
+	export class Delete extends Operation {
+		override readonly op = 'delete' as const
+	}
+}

package/src/graphQlBuilder/GraphQlBuilderError.ts

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

package/src/graphQlBuilder/GraphQlLiteral.ts

@@ -0,0 +1,7 @@
+export class GraphQlLiteral<Value extends string = string> {
+	constructor(public readonly value: Value) {}
+
+	public toString() {
+		return `Literal(${this.value})`
+	}
+}

package/src/graphQlBuilder/ObjectBuilder.ts

@@ -0,0 +1,87 @@
+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/QueryBuilder.ts

@@ -0,0 +1,34 @@
+import type { GraphQlLiteral } from './GraphQlLiteral'
+import { QueryCompiler } from './QueryCompiler'
+import { RootObjectBuilder } from './RootObjectBuilder'
+
+class QueryBuilder {
+	query(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string {
+		if (!(builder instanceof RootObjectBuilder)) {
+			builder = builder(new RootObjectBuilder())
+		}
+		const compiler = new QueryCompiler('query', builder)
+		return compiler.create()
+	}
+
+	mutation(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string {
+		if (!(builder instanceof RootObjectBuilder)) {
+			builder = builder(new RootObjectBuilder())
+		}
+		const compiler = new QueryCompiler('mutation', builder)
+		return compiler.create()
+	}
+}
+
+namespace QueryBuilder {
+	export interface Object {
+		[key: string]: Value
+	}
+
+	export interface List extends Array<Value> {}
+
+	export type AtomicValue = string | null | number | boolean | GraphQlLiteral
+	export type Value = AtomicValue | QueryBuilder.Object | List
+}
+
+export { QueryBuilder }