@contember/client-content 1.3.0-alpha.2

package/dist/types/utils/createListArgs.d.ts

@@ -0,0 +1,9 @@
+import { SchemaEntityNames } from '../types';
+import { GraphQlFieldTypedArgs } from '@contember/graphql-builder';
+export declare const createListArgs: (entity: SchemaEntityNames<string>, args: {
+    filter?: any;
+    orderBy?: any;
+    limit?: number;
+    offset?: number;
+}, type?: 'list' | 'paginate') => GraphQlFieldTypedArgs;
+//# sourceMappingURL=createListArgs.d.ts.map

package/dist/types/utils/createListArgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createListArgs.d.ts","sourceRoot":"","sources":["../../../src/utils/createListArgs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAElE,eAAO,MAAM,cAAc,WAAY,kBAAkB,MAAM,CAAC,QAAQ;IAAE,MAAM,CAAC,EAAE,GAAG,CAAC;IAAC,OAAO,CAAC,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,SAAQ,MAAM,GAAG,UAAU,KAAY,qBAmB9K,CAAA"}

package/dist/types/utils/createMutationOperationSet.d.ts

@@ -0,0 +1,4 @@
+import { ContentMutation, ContentQuery } from '../nodes';
+import { ContentOperationSet } from './ContentOperationSet';
+export declare const createMutationOperationSet: (input: Record<string, ContentMutation<any> | ContentQuery<any>> | ContentMutation<any> | ContentMutation<any>[]) => ContentOperationSet<any>;
+//# sourceMappingURL=createMutationOperationSet.d.ts.map

package/dist/types/utils/createMutationOperationSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMutationOperationSet.d.ts","sourceRoot":"","sources":["../../../src/utils/createMutationOperationSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAoB,YAAY,EAAE,MAAM,UAAU,CAAA;AAE1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE3D,eAAO,MAAM,0BAA0B,UAEnC,OAAO,MAAM,EAAE,gBAAgB,GAAG,CAAC,GAAG,aAAa,GAAG,CAAC,CAAC,GACxD,gBAAgB,GAAG,CAAC,GACpB,gBAAgB,GAAG,CAAC,EAAE,KACvB,oBAAoB,GAAG,CAgCzB,CAAA"}

package/dist/types/utils/createQueryOperationSet.d.ts

@@ -0,0 +1,4 @@
+import { ContentQuery } from '../nodes';
+import { ContentOperationSet } from './ContentOperationSet';
+export declare const createQueryOperationSet: (input: Record<string, ContentQuery<any>> | ContentQuery<any>) => ContentOperationSet<any>;
+//# sourceMappingURL=createQueryOperationSet.d.ts.map

package/dist/types/utils/createQueryOperationSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQueryOperationSet.d.ts","sourceRoot":"","sources":["../../../src/utils/createQueryOperationSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,YAAY,EAAE,MAAM,UAAU,CAAA;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAG3D,eAAO,MAAM,uBAAuB,UAC5B,OAAO,MAAM,EAAE,aAAa,GAAG,CAAC,CAAC,GAAG,aAAa,GAAG,CAAC,KAC1D,oBAAoB,GAAG,CAazB,CAAA"}

package/dist/types/utils/createTypedArgs.d.ts

@@ -0,0 +1,3 @@
+import { GraphQlFieldTypedArgs } from '@contember/graphql-builder';
+export declare const createTypedArgs: <TArgs extends Record<string, any>>(args: TArgs, types: { [key in keyof TArgs]: string; }) => GraphQlFieldTypedArgs;
+//# sourceMappingURL=createTypedArgs.d.ts.map

package/dist/types/utils/createTypedArgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypedArgs.d.ts","sourceRoot":"","sources":["../../../src/utils/createTypedArgs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAElE,eAAO,MAAM,eAAe,gGAGzB,qBASF,CAAA"}

package/dist/types/utils/mutationFragments.d.ts

@@ -0,0 +1,3 @@
+import { GraphQlFragment } from '@contember/graphql-builder';
+export declare const mutationFragments: Record<string, GraphQlFragment>;
+//# sourceMappingURL=mutationFragments.d.ts.map

package/dist/types/utils/mutationFragments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationFragments.d.ts","sourceRoot":"","sources":["../../../src/utils/mutationFragments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,eAAe,EAAgD,MAAM,4BAA4B,CAAA;AAExH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAiD7D,CAAA"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@contember/client-content",
+  "license": "Apache-2.0",
+  "version": "1.3.0-alpha.2",
+  "main": "./dist/production/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "development": "./dist/development/index.js",
+        "production": "./dist/production/index.js",
+        "default": "./dist/production/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "development": "./dist/development/index.cjs",
+        "production": "./dist/production/index.cjs",
+        "default": "./dist/production/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "typings": "./dist/types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "build": "yarn build:js:dev && yarn build:js:prod",
+    "build:js:dev": "NODE_ENV=development vite build --mode development",
+    "build:js:prod": "vite build --mode production",
+    "ae:build": "api-extractor run --local",
+    "ae:test": "api-extractor run",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@contember/graphql-builder": "1.3.0-alpha.2",
+    "@contember/graphql-client": "1.3.0-alpha.2",
+    "@contember/schema": "^1.3.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/contember/interface.git",
+    "directory": "packages/client-content"
+  },
+  "stableVersion": "0.0.0"
+}

package/src/ContentClient.ts

@@ -0,0 +1,42 @@
+import { mutationFragments } from './utils/mutationFragments'
+import { GraphQlClientRequestOptions } from '@contember/graphql-client'
+import { GraphQlQueryPrinter } from '@contember/graphql-builder'
+import { ContentMutation, ContentQuery } from './nodes'
+import { createMutationOperationSet } from './utils/createMutationOperationSet'
+import { createQueryOperationSet } from './utils/createQueryOperationSet'
+
+
+export type QueryExecutorOptions = GraphQlClientRequestOptions
+
+export type QueryExecutor = <T = unknown>(query: string, options: GraphQlClientRequestOptions) => Promise<T>
+
+export class ContentClient {
+	constructor(
+		private readonly executor: QueryExecutor,
+	) {
+	}
+
+
+	public async query<Value>(query: ContentQuery<Value>, options?: QueryExecutorOptions): Promise<Value>
+	public async query<Values extends Record<string, any>>(queries: {[K in keyof Values]: ContentQuery<Values[K]>}, options?: QueryExecutorOptions): Promise<Values>
+	public async query(queries: Record<string, ContentQuery<any>> | ContentQuery<any>, options?: QueryExecutorOptions): Promise<any> {
+		const printer = new GraphQlQueryPrinter()
+		const operationSet = createQueryOperationSet(queries)
+		const { query, variables } = printer.printDocument('query', operationSet.selection, {})
+		const result = await this.executor(query, { variables, ...options })
+		return operationSet.parse(result)
+	}
+
+	public async mutate<Value>(mutation: ContentMutation<Value>, options?: QueryExecutorOptions,): Promise<Value>
+	public async mutate<Value>(mutations: ContentMutation<Value>[], options?: QueryExecutorOptions,): Promise<Value[]>
+	public async mutate<Values extends Record<string, any>>(mutations: { [K in keyof Values]: ContentMutation<Values[K]> | ContentQuery<Values[K]> }, options?: QueryExecutorOptions): Promise<Values>
+	public async mutate(input: Record<string, ContentMutation<any> | ContentQuery<any>> | ContentMutation<any> | ContentMutation<any>[], options?: QueryExecutorOptions): Promise<any> {
+		const operationSet = createMutationOperationSet(input)
+
+		const printer = new GraphQlQueryPrinter()
+		const { query, variables } = printer.printDocument('mutation', operationSet.selection, mutationFragments)
+		const result = await this.executor(query, { variables, ...options })
+
+		return operationSet.parse(result)
+	}
+}

package/src/ContentQueryBuilder.ts

@@ -0,0 +1,200 @@
+import { ContentClientInput, MutationResult, SchemaNames, TransactionResult } from './types'
+import {
+	ContentEntitySelection,
+	ContentEntitySelectionCallback,
+	ContentEntitySelectionContext,
+	ContentMutation,
+	ContentOperation,
+	ContentQuery,
+} from './nodes'
+import { createListArgs } from './utils/createListArgs'
+import { createTypedArgs } from './utils/createTypedArgs'
+import { Input } from '@contember/schema'
+import { GraphQlField, GraphQlFragmentSpread, GraphQlSelectionSet } from '@contember/graphql-builder'
+import { createMutationOperationSet } from './utils/createMutationOperationSet'
+
+export type EntitySelectionOrCallback =
+	| ContentEntitySelection
+	| ContentEntitySelectionCallback
+
+export type MutationTransactionOptions = {
+	deferForeignKeyConstraints?: boolean
+	deferUniqueConstraints?: boolean
+}
+
+export class ContentQueryBuilder {
+	constructor(private readonly schema: SchemaNames) {
+	}
+
+
+	public fragment(name: string, fieldsCallback?: ContentEntitySelectionCallback): ContentEntitySelection {
+		const context = this.createContext(name)
+
+		const entitySelection = new ContentEntitySelection(context, [])
+		if (!fieldsCallback) {
+			return entitySelection
+		}
+		return fieldsCallback(entitySelection)
+	}
+
+
+
+	public count(name: string, args: Pick<ContentClientInput.AnyListQueryInput, 'filter'>): ContentQuery<number> {
+		const context = this.createContext(name)
+		const fieldName = `paginate${name}`
+		const typedArgs = createTypedArgs(args, {
+			filter: `${context.entity.name}Where`,
+		})
+		const selectionSet: GraphQlSelectionSet = [
+			new GraphQlField(null, 'pageInfo', {}, [
+				new GraphQlField(null, 'totalCount'),
+			]),
+		]
+
+		return new ContentOperation('query', fieldName, typedArgs, selectionSet, it => {
+			return it.pageInfo.totalCount
+		})
+	}
+
+
+	public list(name: string, args: ContentClientInput.AnyListQueryInput, fields: EntitySelectionOrCallback): ContentQuery<any[]> {
+		const context = this.createContext(name)
+		const fieldName = `list${name}`
+		const typedArgs = createListArgs(context.entity, args)
+		const selectionSet = this.resolveSelectionSet(fields, context)
+
+		return new ContentOperation('query', fieldName, typedArgs, selectionSet)
+	}
+
+
+	public get(name: string, args: Input.UniqueQueryInput, fields: EntitySelectionOrCallback): ContentQuery<Record<string, unknown> | null> {
+		const context = this.createContext(name)
+		const fieldName = `get${name}`
+		const typedArgs = createTypedArgs(args, {
+			by: `${context.entity.name}UniqueWhere!`,
+			filter: `${context.entity.name}Where`,
+		})
+		const selectionSet = this.resolveSelectionSet(fields, context)
+
+		return new ContentOperation('query', fieldName, typedArgs, selectionSet)
+	}
+
+
+	public create(name: string, args: Input.CreateInput, fields?: EntitySelectionOrCallback): ContentMutation<MutationResult> {
+
+		const context = this.createContext(name)
+		const fieldName = `create${name}`
+		const typedArgs = createTypedArgs(args, {
+			data: `${context.entity.name}CreateInput!`,
+		})
+		const selectionSet = this.createMutationSelection('create', fields ? this.resolveSelectionSet(fields, context) : undefined)
+
+		return new ContentOperation('mutation', fieldName, typedArgs, selectionSet)
+	}
+
+
+	public update(name: string, args: Input.UpdateInput, fields?: EntitySelectionOrCallback): ContentMutation<MutationResult> {
+
+		const context = this.createContext(name)
+		const fieldName = `update${name}`
+		const typedArgs = createTypedArgs(args, {
+			data: `${context.entity.name}UpdateInput!`,
+			by: `${context.entity.name}UniqueWhere!`,
+			filter: `${context.entity.name}Where`,
+		})
+		const selectionSet = this.createMutationSelection('update', fields ? this.resolveSelectionSet(fields, context) : undefined)
+
+		return new ContentOperation('mutation', fieldName, typedArgs, selectionSet)
+	}
+
+
+	public upsert(name: string, args: Input.UpsertInput, fields?: EntitySelectionOrCallback): ContentMutation<MutationResult> {
+
+		const context = this.createContext(name)
+		const fieldName = `upsert${name}`
+		const typedArgs = createTypedArgs(args, {
+			update: `${context.entity.name}UpdateInput!`,
+			create: `${context.entity.name}CreateInput!`,
+			by: `${context.entity.name}UniqueWhere!`,
+			filter: `${context.entity.name}Where`,
+		})
+
+		const selectionSet = this.createMutationSelection('upsert', fields ? this.resolveSelectionSet(fields, context) : undefined)
+
+		return new ContentOperation('mutation', fieldName, typedArgs, selectionSet)
+	}
+
+
+	public delete(name: string, args: Input.UniqueQueryInput, fields?: EntitySelectionOrCallback): ContentMutation<MutationResult> {
+
+		const context = this.createContext(name)
+		const typedArgs = createTypedArgs(args, {
+			by: `${context.entity.name}UniqueWhere!`,
+			filter: `${context.entity.name}Where`,
+		})
+		const fieldName = `delete${name}`
+		const selectionSet = this.createMutationSelection('delete', fields ? this.resolveSelectionSet(fields, context) : undefined)
+
+		return new ContentOperation('mutation', fieldName, typedArgs, selectionSet)
+	}
+
+	public transaction(
+		input: Record<string, ContentMutation<any> | ContentQuery<any>> | ContentMutation<any> | ContentMutation<any>[],
+		options: MutationTransactionOptions = {},
+	): ContentMutation<TransactionResult<any>> {
+		const combined = createMutationOperationSet(input)
+
+		const transactionArgs = createTypedArgs({ options }, {
+			options: 'MutationTransactionOptions',
+		})
+		return new ContentOperation<TransactionResult<any>, 'mutation'>('mutation', 'transaction', transactionArgs, combined.selection, ({ ok, errorMessage, errors, validation, ...data }) => {
+			return {
+				ok,
+				errorMessage,
+				errors,
+				validation,
+				data: combined.parse(data),
+			}
+		})
+	}
+
+	private createMutationSelection(operation: 'create' | 'update' | 'delete' | 'upsert', selection?: GraphQlSelectionSet): GraphQlSelectionSet {
+		const items: GraphQlSelectionSet = [
+			new GraphQlField(null, 'ok'),
+			new GraphQlField(null, 'errorMessage'),
+			new GraphQlField(null, 'errors', {}, [
+				new GraphQlFragmentSpread('MutationError'),
+			]),
+		]
+		if (operation !== 'delete') {
+			items.push(new GraphQlField(null, 'validation', {}, [
+				new GraphQlFragmentSpread('ValidationResult'),
+			]))
+		}
+		if (selection) {
+			items.push(new GraphQlField(null, 'node', {}, selection))
+		}
+		return items
+	}
+
+
+	private resolveSelectionSet(
+		fields: EntitySelectionOrCallback,
+		context: ContentEntitySelectionContext<string>,
+	) {
+		return (typeof fields === 'function' ? fields(new ContentEntitySelection(context, [])) : fields).selectionSet
+	}
+
+	private createContext(
+		name: string,
+	): ContentEntitySelectionContext<string> {
+		const entity = this.schema.entities[name]
+		if (!entity) {
+			throw new Error(`Entity ${name} not found`)
+		}
+		return {
+			entity: entity,
+			schema: this.schema,
+		}
+	}
+}

package/src/TypedContentQueryBuilder.ts

@@ -0,0 +1,76 @@
+import { ContentClientInput, MutationResult, SchemaTypeLike, TransactionResult } from './types'
+import { ContentMutation, ContentQuery, TypedEntitySelection, TypedEntitySelectionCallback } from './nodes'
+import { MutationTransactionOptions } from './ContentQueryBuilder'
+
+
+export type TypedContentEntitySelectionOrCallback<TSchema extends SchemaTypeLike, TEntityName extends keyof TSchema['entities'] & string, TValue> =
+	| TypedEntitySelection<TSchema, TEntityName, TSchema['entities'][TEntityName], TValue>
+	| TypedEntitySelectionCallback<TSchema, TEntityName, TSchema['entities'][TEntityName], TValue>
+
+
+export interface TypedContentQueryBuilder<TSchema extends SchemaTypeLike> {
+
+	fragment<EntityName extends keyof TSchema['entities'] & string>(
+		name: EntityName,
+	): TypedEntitySelection<TSchema, EntityName, TSchema['entities'][EntityName], {}>
+	fragment<EntityName extends keyof TSchema['entities'] & string, TFields>(
+		name: EntityName,
+		fieldsCallback: TypedEntitySelectionCallback<TSchema, EntityName, TSchema['entities'][EntityName], TFields>,
+	): TypedEntitySelection<TSchema, EntityName, TSchema['entities'][EntityName], TFields>
+
+	count<EntityName extends keyof TSchema['entities'] & string>(
+		name: EntityName,
+		args: Pick<ContentClientInput.ListQueryInput<TSchema['entities'][EntityName]>, 'filter'>,
+	): ContentQuery<number>
+
+	list<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.ListQueryInput<TSchema['entities'][EntityName]>,
+		fields: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentQuery<TValue[]>
+
+	get<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.UniqueQueryInput<TSchema['entities'][EntityName]>,
+		fields: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentQuery<TValue | null>
+
+	create<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.CreateInput<TSchema['entities'][EntityName]>,
+		fields?: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentMutation<MutationResult<TValue>>
+
+	update<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.UpdateInput<TSchema['entities'][EntityName]>,
+		fields?: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentMutation<MutationResult<TValue>>
+
+	upsert<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.UpsertInput<TSchema['entities'][EntityName]>,
+		fields?: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentMutation<MutationResult<TValue>>
+
+	delete<EntityName extends keyof TSchema['entities'] & string, TValue>(
+		name: EntityName,
+		args: ContentClientInput.UniqueQueryInput<TSchema['entities'][EntityName]>,
+		fields?: TypedContentEntitySelectionOrCallback<TSchema, EntityName, TValue>,
+	): ContentMutation<MutationResult<TValue>>
+
+	transaction<Value>(
+		mutation: ContentMutation<Value>,
+		options?: MutationTransactionOptions,
+	): ContentMutation<TransactionResult<Value>>
+	transaction<Value>(
+		mutations: ContentMutation<Value>[],
+		options?: MutationTransactionOptions,
+	): ContentMutation<TransactionResult<Value[]>>
+
+	transaction<Values extends Record<string, any>>(
+		mutations: { [K in keyof Values]: ContentMutation<Values[K]> | ContentQuery<Values[K]> },
+		options?: MutationTransactionOptions,
+	): ContentMutation<TransactionResult<Values>>
+}
+

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './ContentClient'
+export * from './TypedContentQueryBuilder'
+export * from './ContentQueryBuilder'
+export * from './nodes'
+export * from './types'

package/src/nodes/ContentEntitySelection.ts

@@ -0,0 +1,240 @@
+import { createListArgs } from '../utils/createListArgs'
+import { ContentClientInput, SchemaEntityNames, SchemaNames } from '../types'
+import { Input } from '@contember/schema'
+import { GraphQlField, GraphQlFieldTypedArgs, GraphQlSelectionSet } from '@contember/graphql-builder'
+
+/**
+ * @internal
+ */
+export type ContentEntitySelectionContext<Name extends string> = {
+	entity: SchemaEntityNames<Name>
+	schema: SchemaNames
+}
+
+export type ContentEntitySelectionCallback = (select: ContentEntitySelection) => ContentEntitySelection
+
+export type EntitySelectionCommonInput<Alias extends string | null = string | null> = { as?: Alias }
+export type EntitySelectionManyArgs<Alias extends string | null = string | null> = ContentClientInput.AnyListQueryInput & EntitySelectionCommonInput<Alias>
+export type EntitySelectionManyByArgs<Alias extends string | null = string | null> = { by: Input.UniqueWhere; filter?: Input.Where } & EntitySelectionCommonInput<Alias>
+export type EntitySelectionOneArgs<Alias extends string | null = string | null> = { filter?: Input.Where } & EntitySelectionCommonInput<Alias>
+export type EntitySelectionColumnArgs<Alias extends string | null = string | null> = EntitySelectionCommonInput<Alias>
+
+export type EntitySelectionAnyArgs =
+	| EntitySelectionColumnArgs
+	| EntitySelectionManyArgs
+	| EntitySelectionManyByArgs
+	| EntitySelectionOneArgs
+
+export type ContentEntitySelectionOrCallback = ContentEntitySelectionCallback | ContentEntitySelection
+
+
+export class ContentEntitySelection {
+
+	/**
+	 * @internal
+	 */
+	constructor(
+		/** @internal */
+		public readonly context: ContentEntitySelectionContext<string>,
+		/** @internal */
+		public readonly selectionSet: GraphQlSelectionSet,
+	) {
+	}
+
+
+	$(field: string, args?: EntitySelectionColumnArgs): ContentEntitySelection
+	$(field: string, args: EntitySelectionManyArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, args: EntitySelectionManyByArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, args: EntitySelectionOneArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+
+	$(field: string, argsOrSelection?: EntitySelectionAnyArgs | ContentEntitySelectionOrCallback, selectionIn?: ContentEntitySelectionOrCallback): ContentEntitySelection {
+		const [args, selection] = typeof argsOrSelection === 'function' || argsOrSelection instanceof ContentEntitySelection
+			? [{}, argsOrSelection]
+			: [argsOrSelection ?? {}, selectionIn]
+		if (field === '__typename') {
+			return this.withField(new GraphQlField(args.as ?? null, '__typename'))
+		}
+		const fieldInfo = this.context.entity.fields[field]
+		if (!fieldInfo) {
+			if ('by' in args && field.includes('By')) {
+				if (!selection) {
+					throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+				}
+				return this._manyBy(field, args as EntitySelectionManyByArgs, selection)
+			}
+
+			throw new Error(`Field ${this.context.entity.name}.${field} does not exist.`)
+		}
+		if (fieldInfo.type === 'column') {
+			return this._column(field, args as EntitySelectionColumnArgs)
+		}
+		if (fieldInfo.type === 'many') {
+			if (!selection) {
+				throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+			}
+			return this._many(field, args as EntitySelectionManyArgs, selection)
+		}
+		if (fieldInfo.type === 'one') {
+			if (!selection) {
+				throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+			}
+			return this._one(field, args as EntitySelectionOneArgs, selection)
+		}
+		throw new Error(`Unknown field type ${fieldInfo.type}.`)
+	}
+
+	$$(): ContentEntitySelection {
+		const columns = this.context.entity.scalars
+		const nodes = [
+			...this.selectionSet,
+			...columns.map(col => new GraphQlField(null, col)),
+		]
+		return new ContentEntitySelection(this.context, nodes)
+	}
+
+	private _column(
+		name: string,
+		args: EntitySelectionCommonInput = {},
+	): ContentEntitySelection {
+		let fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'column') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a column.`)
+		}
+
+		const alias = args.as ?? name
+
+		const field = new GraphQlField(alias, name, {})
+		return this.withField(field)
+	}
+
+
+	private _many(
+		name: string,
+		args: EntitySelectionManyArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection{
+		const alias = args.as ?? name
+		const fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'many') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a has-many relation.`)
+		}
+		const entity = this.context.schema.entities[fieldInfo.entity]
+
+		const newContext = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+
+		const entitySelection = typeof fields === 'function' ? fields(new ContentEntitySelection(newContext, [])) : fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			createListArgs(entity, args),
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+
+	private _manyBy(
+		name: string,
+		args: EntitySelectionManyByArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection {
+		const alias = args.as ?? name
+		const byField = Object.keys(args.by)[0]
+		const relationField = name.substring(0, name.length - byField.length - 2)
+
+		const field = this.context.entity.fields[relationField]
+		if (!field) {
+			throw new Error(`Field ${this.context.entity.name}.${relationField} does not exist.`)
+		}
+		if (field?.type !== 'many') {
+			throw new Error(`Field ${this.context.entity.name}.${relationField} is not a has-many relation.`)
+		}
+		const entity = this.context.schema.entities[field.entity]
+		const newContext = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+		const fieldUpperFirst = name.charAt(0).toUpperCase() + name.slice(1)
+
+		const argsWithType: GraphQlFieldTypedArgs = {
+			filter: {
+				graphQlType: `${entity.name}Where`,
+				value: args.filter,
+			},
+			by: {
+				graphQlType: `${this.context.entity.name}${fieldUpperFirst}UniqueWhere!`,
+				value: args.by,
+			},
+		}
+
+		const entitySelection = typeof fields === 'function' ? fields(new ContentEntitySelection(newContext, []) as any) : fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			argsWithType,
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+	private _one(
+		name: string,
+		args: EntitySelectionOneArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection {
+		const alias = args.as ?? name
+		const fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'one') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a has-one relation.`)
+		}
+		const entity = this.context.schema.entities[fieldInfo.entity]
+
+		const newContext: ContentEntitySelectionContext<(typeof entity)['name']> = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+		const argsWithType: GraphQlFieldTypedArgs = {
+			filter: {
+				graphQlType: `${entity.name}Where`,
+				value: args.filter,
+			},
+		}
+		const entitySelection = typeof fields === 'function'
+			? fields(new ContentEntitySelection(newContext, []) as any)
+			: fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			argsWithType,
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+
+	private withField(field: GraphQlField) {
+		return new ContentEntitySelection(this.context, [
+			...this.selectionSet,
+			field,
+		])
+	}
+}