@contember/binding-common 2.0.0-alpha.17

package/src/markers/FieldMarker.ts

@@ -0,0 +1,29 @@
+import type { FieldName, FieldValue, RelativeSingleField } from '../treeParameters'
+import { PlaceholderGenerator } from './PlaceholderGenerator'
+
+/**
+ * A nonbearing field is only defined in context of create mutations. An entity will be created if and only if some
+ * other fields (not just nonbearing fields) are filled as well. This is particularly useful for programmatically
+ * controlled fields within repeaters.
+ */
+export class FieldMarker {
+	public readonly placeholderName: string
+
+	constructor(
+		public readonly parameters: Omit<RelativeSingleField, 'hasOneRelationPath'>,
+	) {
+		this.placeholderName = PlaceholderGenerator.getFieldPlaceholder(this.parameters.field)
+	}
+
+	get fieldName(): FieldName {
+		return this.parameters.field
+	}
+
+	get isNonbearing(): boolean {
+		return this.parameters.isNonbearing
+	}
+
+	get defaultValue(): FieldValue | undefined {
+		return this.parameters.defaultValue
+	}
+}

package/src/markers/HasManyRelationMarker.ts

@@ -0,0 +1,27 @@
+import { BindingError } from '../BindingError'
+import type { Environment } from '../environment'
+import type { HasManyRelation } from '../treeParameters'
+import type { EntityFieldMarkersContainer } from './EntityFieldMarkersContainer'
+import { PlaceholderGenerator } from './PlaceholderGenerator'
+
+// This doesn't represent reduced has many relations.
+export class HasManyRelationMarker {
+	public readonly placeholderName: string
+
+	public constructor(
+		public readonly parameters: HasManyRelation,
+		public readonly fields: EntityFieldMarkersContainer,
+		public readonly environment: Environment,
+	) {
+		if (import.meta.env.DEV) {
+			if (parameters.initialEntityCount < 0 || !Number.isInteger(parameters.initialEntityCount)) {
+				throw new BindingError(`The preferred 'initialEntityCount' for a relation must be a non-negative integer!`)
+			}
+		}
+		this.placeholderName = PlaceholderGenerator.getHasManyRelationPlaceholder(this.parameters)
+	}
+
+	public get isNonbearing() {
+		return this.parameters.isNonbearing
+	}
+}

package/src/markers/HasOneRelationMarker.ts

@@ -0,0 +1,21 @@
+import type { Environment } from '../environment'
+import type { HasOneRelation } from '../treeParameters'
+import type { EntityFieldMarkersContainer } from './EntityFieldMarkersContainer'
+import { PlaceholderGenerator } from './PlaceholderGenerator'
+
+// This may also represent a reduced has many relation.
+export class HasOneRelationMarker {
+	public readonly placeholderName: string
+
+	public constructor(
+		public readonly parameters: HasOneRelation,
+		public readonly fields: EntityFieldMarkersContainer,
+		public readonly environment: Environment,
+	) {
+		this.placeholderName = PlaceholderGenerator.getHasOneRelationPlaceholder(this.parameters)
+	}
+
+	public get isNonbearing() {
+		return this.parameters.isNonbearing
+	}
+}

package/src/markers/MarkerComparator.ts

@@ -0,0 +1,102 @@
+import { PRIMARY_KEY_NAME, TYPENAME_KEY_NAME } from '../consts'
+import {
+	EntityFieldMarkersContainer,
+	EntityListSubTreeMarker,
+	EntitySubTreeMarker,
+	FieldMarker,
+	HasManyRelationMarker,
+	HasOneRelationMarker,
+} from '../markers'
+import { assertNever } from '../utils/assertNever'
+import { LocalizedBindingError } from '../LocalizedBindingError'
+
+export class MarkerComparator {
+	public static isSubTreeSubsetOf(
+		candidate: EntitySubTreeMarker | EntityListSubTreeMarker,
+		superset: EntitySubTreeMarker | EntityListSubTreeMarker,
+	): boolean {
+		if (candidate.placeholderName !== superset.placeholderName) {
+			return false
+		}
+		return this.isSubsetOf(candidate.fields, superset.fields)
+	}
+
+	public static assertEntityMarkersSubsetOf(
+		candidate: EntityFieldMarkersContainer,
+		superset: EntityFieldMarkersContainer,
+	) {
+		this.assertSubsetOf(candidate, superset)
+	}
+
+	private static assertSubsetOf(candidate: EntityFieldMarkersContainer, superset: EntityFieldMarkersContainer) {
+		for (const [placeholderName, candidateMarker] of candidate.markers) {
+			const fromSuperset = superset.markers.get(placeholderName)
+
+			if (fromSuperset === undefined) {
+				if (candidateMarker instanceof FieldMarker) {
+					if (candidateMarker.fieldName === PRIMARY_KEY_NAME || candidateMarker.fieldName === TYPENAME_KEY_NAME) {
+						continue
+					}
+					throw new LocalizedBindingError(`The field '${candidateMarker.fieldName}' is missing.`, [candidateMarker])
+				}
+				if (candidateMarker instanceof HasOneRelationMarker || candidateMarker instanceof HasManyRelationMarker) {
+					const differentPlaceholders = superset.placeholders.get(candidateMarker.parameters.field)
+
+					if (differentPlaceholders === undefined) {
+						throw new LocalizedBindingError(`The relation '${candidateMarker.parameters.field}' is missing.`, [
+							candidateMarker,
+						])
+					}
+					// TODO be more specific
+					throw new LocalizedBindingError(
+						`The relation '${candidateMarker.parameters.field}' exists but its parameters don't match exactly. ` +
+							`Check that all relation parameters are the same.`,
+						[candidateMarker],
+					)
+				}
+				assertNever(candidateMarker)
+			}
+			if (candidateMarker instanceof FieldMarker) {
+				continue
+			}
+			try {
+				if (
+					(candidateMarker instanceof HasOneRelationMarker && fromSuperset instanceof HasOneRelationMarker) ||
+					(candidateMarker instanceof HasManyRelationMarker && fromSuperset instanceof HasManyRelationMarker)
+				) {
+					this.assertSubsetOf(candidateMarker.fields, fromSuperset.fields)
+				}
+			} catch (e) {
+				if (e instanceof LocalizedBindingError) {
+					throw e.nestedIn(candidateMarker)
+				}
+				throw e
+			}
+		}
+	}
+
+	private static isSubsetOf(candidate: EntityFieldMarkersContainer, superset: EntityFieldMarkersContainer): boolean {
+		for (const [placeholderName, candidateMarker] of candidate.markers) {
+			const fromSuperset = superset.markers.get(placeholderName)
+
+			if (fromSuperset === undefined) {
+				if (
+					candidateMarker instanceof FieldMarker &&
+					(candidateMarker.fieldName === PRIMARY_KEY_NAME || candidateMarker.fieldName === TYPENAME_KEY_NAME)
+				) {
+					continue
+				}
+				return false
+			}
+			if (candidateMarker instanceof FieldMarker || fromSuperset instanceof FieldMarker) {
+				continue
+			}
+			if (!this.isSubsetOf(candidateMarker.fields, fromSuperset.fields)) {
+				return false
+			}
+		}
+		return true
+	}
+
+	//private static assertAreMarkersSubsetOf(): {}
+}

package/src/markers/MarkerMerger.ts

@@ -0,0 +1,300 @@
+import { BindingError } from '../BindingError'
+import { PRIMARY_KEY_NAME } from '../consts'
+import {
+	EntityFieldMarkers,
+	EntityFieldMarkersContainer,
+	EntityFieldPlaceholders,
+	EntityListSubTreeMarker,
+	EntitySubTreeMarker,
+	FieldMarker,
+	HasManyRelationMarker,
+	HasOneRelationMarker,
+	MarkerTreeRoot,
+	MeaningfulMarker,
+	SubTreeMarkers,
+} from '../markers'
+import type { Alias, FieldName, PlaceholderName } from '../treeParameters'
+import { assertNever } from '../utils/assertNever'
+import { TreeParameterMerger } from '../treeParameters/TreeParameterMerger'
+import { Environment } from '../environment'
+
+export class MarkerMerger {
+	// This method assumes their placeholder names are the same
+	public static mergeMarkers(original: MeaningfulMarker, fresh: MeaningfulMarker): MeaningfulMarker {
+		if (original === fresh) {
+			return original
+		}
+		if (original instanceof FieldMarker) {
+			if (fresh instanceof FieldMarker) {
+				return this.mergeFieldMarkers(original, fresh)
+			} else if (fresh instanceof HasOneRelationMarker || fresh instanceof HasManyRelationMarker) {
+				return this.rejectRelationScalarCombo(original.fieldName)
+			} else if (fresh instanceof EntitySubTreeMarker || fresh instanceof EntityListSubTreeMarker) {
+				throw new BindingError('Merging fields and sub trees is an undefined operation.')
+			}
+			assertNever(fresh)
+		} else if (original instanceof HasOneRelationMarker) {
+			if (fresh instanceof HasOneRelationMarker) {
+				return this.mergeHasOneRelationMarkers(original, fresh)
+			} else if (fresh instanceof FieldMarker) {
+				return this.rejectRelationScalarCombo(original.parameters.field)
+			} else if (fresh instanceof HasManyRelationMarker) {
+				throw new BindingError() // TODO not implemented
+			} else if (fresh instanceof EntitySubTreeMarker || fresh instanceof EntityListSubTreeMarker) {
+				throw new BindingError('MarkerTreeGenerator merging: SubTreeMarkers can only be merged with other sub trees.')
+			}
+			assertNever(fresh)
+		} else if (original instanceof HasManyRelationMarker) {
+			if (fresh instanceof HasManyRelationMarker) {
+				return this.mergeHasManyRelationMarkers(original, fresh)
+			} else if (fresh instanceof FieldMarker) {
+				return this.rejectRelationScalarCombo(original.parameters.field)
+			} else if (fresh instanceof HasOneRelationMarker) {
+				throw new BindingError() // TODO not implemented
+			} else if (fresh instanceof EntitySubTreeMarker || fresh instanceof EntityListSubTreeMarker) {
+				throw new BindingError('MarkerTreeGenerator merging: SubTreeMarkers can only be merged with other sub trees.')
+			}
+			assertNever(fresh)
+		} else if (original instanceof EntitySubTreeMarker) {
+			if (fresh instanceof EntitySubTreeMarker) {
+				return this.mergeEntitySubTreeMarkers(original, fresh)
+			} else {
+				throw new BindingError(
+					'MarkerTreeGenerator merging: EntitySubTreeMarker can only be merged with other entity sub trees.',
+				)
+			}
+		} else if (original instanceof EntityListSubTreeMarker) {
+			if (fresh instanceof EntityListSubTreeMarker) {
+				return this.mergeEntityListSubTreeMarkers(original, fresh)
+			} else {
+				throw new BindingError(
+					'MarkerTreeGenerator merging: EntityListSubTreeMarker can only be merged with other list sub trees.',
+				)
+			}
+		}
+		assertNever(original)
+	}
+
+	public static mergeMarkerTreeRoots(original: MarkerTreeRoot, fresh: MarkerTreeRoot): MarkerTreeRoot {
+		if (original === fresh) {
+			return original
+		}
+		return new MarkerTreeRoot(
+			this.mergeEntityFields(original.subTrees, fresh.subTrees),
+			this.mergeSubTreePlaceholdersByAliases(original.placeholdersByAliases, fresh.placeholdersByAliases),
+		)
+	}
+
+	public static mergeSubTreeMarkers(
+		original: SubTreeMarkers | undefined,
+		fresh: SubTreeMarkers | undefined,
+	): SubTreeMarkers | undefined {
+		if (original === fresh) {
+			return original
+		}
+		if (original === undefined) {
+			return fresh
+		}
+		if (fresh === undefined) {
+			return original
+		}
+		const newOriginal = new Map(original)
+
+		for (const [placeholderName, fromFresh] of fresh) {
+			const fromOriginal = newOriginal.get(placeholderName)
+
+			newOriginal.set(
+				placeholderName,
+				fromOriginal === undefined
+					? fromFresh
+					: fromOriginal instanceof EntityListSubTreeMarker
+						? MarkerMerger.mergeEntityListSubTreeMarkers(fromOriginal, fromFresh as EntityListSubTreeMarker)
+						: MarkerMerger.mergeEntitySubTreeMarkers(fromOriginal, fromFresh as EntitySubTreeMarker),
+			)
+		}
+		return newOriginal
+	}
+
+	public static mergeSubTreePlaceholdersByAliases(
+		original: ReadonlyMap<Alias, PlaceholderName>,
+		fresh: ReadonlyMap<Alias, PlaceholderName>,
+	) {
+		const newOriginalAliases = new Map(original)
+		for (const [alias, placeholder] of fresh) {
+			const fromOriginal = newOriginalAliases.get(alias)
+			if (fromOriginal === undefined) {
+				newOriginalAliases.set(alias, placeholder)
+			} else if (fromOriginal === placeholder) {
+				// Do nothing
+			} else {
+				throw new BindingError(`Illegal subTree alias '${alias}' points to distinct subTrees.`)
+			}
+		}
+		return newOriginalAliases
+	}
+
+	public static mergeEntityFields(original: SubTreeMarkers, fresh: SubTreeMarkers): SubTreeMarkers
+	public static mergeEntityFields(original: EntityFieldMarkers, fresh: EntityFieldMarkers): EntityFieldMarkers
+	public static mergeEntityFields(
+		original: ReadonlyMap<PlaceholderName, MeaningfulMarker>,
+		fresh: ReadonlyMap<PlaceholderName, MeaningfulMarker>,
+	): ReadonlyMap<PlaceholderName, MeaningfulMarker> {
+		if (original === fresh) {
+			return original
+		}
+		if (original.size === 0) {
+			return fresh
+		}
+		const newOriginal: Map<PlaceholderName, MeaningfulMarker> = new Map(original)
+		for (const [placeholderName, freshMarker] of fresh) {
+			const markerFromOriginal = newOriginal.get(placeholderName)
+			newOriginal.set(
+				placeholderName,
+				markerFromOriginal === undefined ? freshMarker : this.mergeMarkers(markerFromOriginal, freshMarker),
+			)
+		}
+		return newOriginal
+	}
+
+	public static mergeEntityFieldPlaceholders(
+		original: EntityFieldPlaceholders,
+		fresh: EntityFieldPlaceholders,
+	): EntityFieldPlaceholders {
+		if (original === fresh) {
+			return original
+		}
+		if (original.size === 0) {
+			return fresh
+		}
+		const newOriginal: Map<FieldName, PlaceholderName | Set<PlaceholderName>> = new Map(original)
+		for (const [fieldName, freshPlaceholders] of fresh) {
+			const placeholderFromOriginal = newOriginal.get(fieldName)
+
+			if (placeholderFromOriginal === undefined) {
+				newOriginal.set(fieldName, freshPlaceholders)
+			} else if (placeholderFromOriginal instanceof Set) {
+				const combinedSet = new Set(placeholderFromOriginal)
+				if (freshPlaceholders instanceof Set) {
+					for (const freshPlaceholder of freshPlaceholders) {
+						combinedSet.add(freshPlaceholder)
+					}
+				} else if (typeof freshPlaceholders === 'string') {
+					combinedSet.add(freshPlaceholders)
+				} else {
+					assertNever(freshPlaceholders)
+				}
+				newOriginal.set(fieldName, combinedSet)
+			} else if (typeof placeholderFromOriginal === 'string') {
+				if (typeof freshPlaceholders === 'string') {
+					if (placeholderFromOriginal === freshPlaceholders) {
+						// Do nothing
+					} else {
+						newOriginal.set(fieldName, new Set([placeholderFromOriginal, freshPlaceholders]))
+					}
+				} else if (freshPlaceholders instanceof Set) {
+					if (freshPlaceholders.has(placeholderFromOriginal)) {
+						newOriginal.set(fieldName, freshPlaceholders)
+					} else {
+						const combinedSet = new Set(freshPlaceholders)
+						combinedSet.add(placeholderFromOriginal)
+						newOriginal.set(fieldName, combinedSet)
+					}
+				} else {
+					assertNever(freshPlaceholders)
+				}
+			} else {
+				assertNever(placeholderFromOriginal)
+			}
+		}
+		return newOriginal
+	}
+
+	public static mergeEntityFieldsContainers(
+		original: EntityFieldMarkersContainer,
+		fresh: EntityFieldMarkersContainer,
+	): EntityFieldMarkersContainer {
+		if (original === fresh) {
+			return original
+		}
+		return new EntityFieldMarkersContainer(
+			original.hasAtLeastOneBearingField || fresh.hasAtLeastOneBearingField,
+			this.mergeEntityFields(original.markers, fresh.markers),
+			this.mergeEntityFieldPlaceholders(original.placeholders, fresh.placeholders),
+		)
+	}
+
+	public static mergeHasOneRelationMarkers(original: HasOneRelationMarker, fresh: HasOneRelationMarker) {
+		if (original === fresh) {
+			return original
+		}
+		return new HasOneRelationMarker(
+			TreeParameterMerger.mergeHasOneRelationsWithSamePlaceholders(original.parameters, fresh.parameters),
+			this.mergeEntityFieldsContainers(original.fields, fresh.fields),
+			this.mergeEnvironments(original.environment, fresh.environment),
+		)
+	}
+
+	public static mergeHasManyRelationMarkers(original: HasManyRelationMarker, fresh: HasManyRelationMarker) {
+		if (original === fresh) {
+			return original
+		}
+		return new HasManyRelationMarker(
+			TreeParameterMerger.mergeHasManyRelationsWithSamePlaceholders(original.parameters, fresh.parameters),
+			this.mergeEntityFieldsContainers(original.fields, fresh.fields),
+			this.mergeEnvironments(original.environment, fresh.environment),
+		)
+	}
+
+	public static mergeEntitySubTreeMarkers(original: EntitySubTreeMarker, fresh: EntitySubTreeMarker) {
+		if (original === fresh) {
+			return original
+		}
+		return new EntitySubTreeMarker(
+			TreeParameterMerger.mergeEntitySubTreeParametersWithSamePlaceholders(original.parameters, fresh.parameters),
+			this.mergeEntityFieldsContainers(original.fields, fresh.fields),
+			this.mergeEnvironments(original.environment, fresh.environment),
+		)
+	}
+
+	public static mergeEntityListSubTreeMarkers(original: EntityListSubTreeMarker, fresh: EntityListSubTreeMarker) {
+		if (original === fresh) {
+			return original
+		}
+		return new EntityListSubTreeMarker(
+			TreeParameterMerger.mergeEntityListSubTreeParametersWithSamePlaceholders(original.parameters, fresh.parameters),
+			this.mergeEntityFieldsContainers(original.fields, fresh.fields),
+			this.mergeEnvironments(original.environment, fresh.environment),
+		)
+	}
+
+	public static mergeFieldMarkers(original: FieldMarker, fresh: FieldMarker) {
+		if (original === fresh) {
+			return original
+		}
+		return new FieldMarker(TreeParameterMerger.mergeSingleField(original.parameters, fresh.parameters))
+	}
+
+	public static mergeInSystemFields(original: EntityFieldMarkersContainer | undefined): EntityFieldMarkersContainer {
+		const primaryKey = new FieldMarker({
+			field: PRIMARY_KEY_NAME,
+			defaultValue: undefined,
+			isNonbearing: true,
+			eventListeners: undefined,
+		})
+		// We could potentially share this instance for all fields. Maybe sometime later.
+		const freshFields = new EntityFieldMarkersContainer(
+			false,
+			new Map([[primaryKey.placeholderName, primaryKey]]),
+			new Map([[PRIMARY_KEY_NAME, primaryKey.placeholderName]]),
+		)
+		return original ? this.mergeEntityFieldsContainers(original, freshFields) : freshFields
+	}
+
+	public static mergeEnvironments(original: Environment, fresh: Environment): Environment {
+		return original.merge(fresh)
+	}
+
+	private static rejectRelationScalarCombo(fieldName: FieldName): never {
+		throw new BindingError(`Cannot combine a relation with a scalar field '${fieldName}'.`)
+	}
+}

package/src/markers/MarkerTreeRoot.ts

@@ -0,0 +1,9 @@
+import type { Alias, PlaceholderName } from '../treeParameters'
+import type { SubTreeMarkers } from './SubTreeMarkers'
+
+export class MarkerTreeRoot {
+	public constructor(
+		public readonly subTrees: SubTreeMarkers,
+		public readonly placeholdersByAliases: ReadonlyMap<Alias, PlaceholderName>,
+	) {}
+}

package/src/markers/MeaningfulMarker.ts

@@ -0,0 +1,12 @@
+import type { EntityListSubTreeMarker } from './EntityListSubTreeMarker'
+import type { EntitySubTreeMarker } from './EntitySubTreeMarker'
+import type { FieldMarker } from './FieldMarker'
+import type { HasManyRelationMarker } from './HasManyRelationMarker'
+import type { HasOneRelationMarker } from './HasOneRelationMarker'
+
+export type MeaningfulMarker =
+	| FieldMarker
+	| HasOneRelationMarker
+	| HasManyRelationMarker
+	| EntityListSubTreeMarker
+	| EntitySubTreeMarker

package/src/markers/PlaceholderGenerator.ts

@@ -0,0 +1,40 @@
+import type {
+	FieldName,
+	HasManyRelation,
+	HasOneRelation,
+	QualifiedEntityList,
+	QualifiedSingleEntity,
+	UnconstrainedQualifiedEntityList,
+	UnconstrainedQualifiedSingleEntity,
+} from '../treeParameters'
+import { Hashing } from '../utils/Hashing'
+import { Environment } from '../environment'
+import { PlaceholderParametersGenerator } from './PlaceholderParametersGenerator'
+
+export class PlaceholderGenerator {
+	public static getFieldPlaceholder(fieldName: FieldName): string {
+		return fieldName // hashing intentionally ignored
+	}
+
+	public static getHasOneRelationPlaceholder(relation: HasOneRelation): string {
+		return `${relation.field}_${Hashing.hashAny(PlaceholderParametersGenerator.createHasOneRelationParameters(relation))}`
+	}
+
+	public static getHasManyRelationPlaceholder(relation: HasManyRelation): string {
+		return `${relation.field}_${Hashing.hashAny(PlaceholderParametersGenerator.createHasManyRelationParameters(relation))}`
+	}
+
+	public static getEntitySubTreePlaceholder(
+		subTreeParameters: QualifiedSingleEntity | UnconstrainedQualifiedSingleEntity,
+		environment: Environment,
+	): string {
+		return `est_${Hashing.hashAny(PlaceholderParametersGenerator.createEntitySubTreeParameters(subTreeParameters, environment))}`
+	}
+
+	public static getEntityListSubTreePlaceholder(
+		subTreeParameters: QualifiedEntityList | UnconstrainedQualifiedEntityList,
+		environment: Environment,
+	): string {
+		return `lst_${Hashing.hashAny(PlaceholderParametersGenerator.createEntityListSubTreeParameters(subTreeParameters, environment))}`
+	}
+}

package/src/markers/PlaceholderParametersGenerator.ts

@@ -0,0 +1,79 @@
+import {
+	HasManyRelation,
+	HasOneRelation,
+	QualifiedEntityList,
+	QualifiedSingleEntity,
+	UnconstrainedQualifiedEntityList,
+	UnconstrainedQualifiedSingleEntity,
+} from '../treeParameters'
+import { Environment } from '../environment'
+
+export class PlaceholderParametersGenerator {
+
+	public static createHasOneRelationParameters(relation: HasOneRelation): any {
+		return {
+			type: 'hasOne',
+			field: relation.field,
+			filter: relation.filter,
+			reducedBy: relation.reducedBy,
+		}
+	}
+
+	public static createHasManyRelationParameters(relation: HasManyRelation): any {
+		return {
+			type: 'hasMany',
+			field: relation.field,
+			filter: relation.filter,
+			offset: relation.offset,
+			limit: relation.limit,
+			orderBy: relation.orderBy,
+		}
+	}
+
+	public static createEntityListSubTreeParameters(
+		parameters: QualifiedEntityList | UnconstrainedQualifiedEntityList,
+		environment: Environment,
+	): any {
+		if (parameters.isCreating) {
+			return {
+				type: 'entityListSubtree',
+				isCreating: true,
+				entityName: parameters.entityName,
+				variables: environment.getAllVariables(),
+			}
+		}
+		return {
+			type: 'entityListSubtree',
+			isCreating: false,
+			entityName: parameters.entityName,
+			filter: parameters.filter,
+			offset: parameters.offset,
+			limit: parameters.limit,
+			orderBy: parameters.orderBy,
+			variables: environment.getAllVariables(),
+		}
+	}
+
+	public static createEntitySubTreeParameters(
+		parameters: QualifiedSingleEntity | UnconstrainedQualifiedSingleEntity,
+		environment: Environment,
+	): any {
+		if (parameters.isCreating) {
+			return {
+				type: 'entitySubTree',
+				isCreating: true,
+				entityName: parameters.entityName,
+				variables: environment.getAllVariables(),
+			}
+		}
+		return {
+			type: 'entitySubTree',
+			isCreating: false,
+			where: parameters.where,
+			entityName: parameters.entityName,
+			filter: parameters.filter,
+			variables: environment.getAllVariables(),
+		}
+	}
+
+}

package/src/markers/SubTreeMarkers.ts

@@ -0,0 +1,5 @@
+import type { PlaceholderName } from '../treeParameters'
+import type { EntityListSubTreeMarker } from './EntityListSubTreeMarker'
+import type { EntitySubTreeMarker } from './EntitySubTreeMarker'
+
+export type SubTreeMarkers = ReadonlyMap<PlaceholderName, EntitySubTreeMarker | EntityListSubTreeMarker>

package/src/markers/index.ts

@@ -0,0 +1,17 @@
+export * from './EntityFieldMarkers'
+export * from './EntityFieldMarkersContainer'
+export * from './EntityFieldPlaceholders'
+export * from './EntityFieldsWithHoistablesMarker'
+export * from './EntityListSubTreeMarker'
+export * from './EntitySubTreeMarker'
+export * from './FieldMarker'
+export * from './HasManyRelationMarker'
+export * from './HasOneRelationMarker'
+export * from './MarkerTreeRoot'
+export * from './MeaningfulMarker'
+export * from './PlaceholderGenerator'
+export * from './SubTreeMarkers'
+
+export * from './PlaceholderParametersGenerator'
+export * from './MarkerMerger'
+export * from './MarkerComparator'