@contember/binding-common 2.0.0-alpha.17

package/src/RuntimeId.ts

@@ -0,0 +1,70 @@
+import { generateEnumerabilityPreventingEntropy } from './utils/generateEnumerabilityPreventingEntropy'
+import { EntityId } from './treeParameters'
+
+export type UniqueEntityId = string & { __type: 'UniqueEntityId' }
+
+export interface RuntimeIdSpec {
+	existsOnServer: boolean
+	value: EntityId
+	uniqueValue: UniqueEntityId
+}
+
+export class ServerId implements RuntimeIdSpec {
+	public get existsOnServer(): true {
+		return true
+	}
+	public constructor(public readonly value: EntityId, public readonly entityName: string) {
+	}
+
+	get uniqueValue() {
+		return ServerId.formatUniqueValue(this.value, this.entityName)
+	}
+
+	static formatUniqueValue(id: EntityId, entityName: string): UniqueEntityId {
+		return `${entityName}_${id}` as UniqueEntityId
+	}
+}
+
+export class ClientGeneratedUuid implements RuntimeIdSpec {
+	public get existsOnServer(): false {
+		return false
+	}
+	public constructor(public readonly value: string) {}
+
+	get uniqueValue() {
+		return this.value as UniqueEntityId
+	}
+}
+
+export class UnpersistedEntityDummyId implements RuntimeIdSpec {
+	public get existsOnServer(): false {
+		return false
+	}
+	public readonly value: string
+
+	private static getNextSeed = (() => {
+		let seed = 0
+		return () => seed++
+	})()
+
+	public constructor() {
+		const enumerabilityPreventingEntropy = generateEnumerabilityPreventingEntropy(
+			UnpersistedEntityDummyId.entropyLength,
+		)
+
+		// KEEP THIS IN SYNC WITH THE REGEX BELOW!!!
+		this.value = `adminOnlyDummyId-${enumerabilityPreventingEntropy}-${UnpersistedEntityDummyId.getNextSeed()}`
+	}
+
+	private static entropyLength = 5
+	private static dummyIdRegex = new RegExp(`^adminOnlyDummyId-\\d{${UnpersistedEntityDummyId.entropyLength}}-\\d+$`)
+	public static matchesDummyId(candidate: EntityId): boolean {
+		return typeof candidate === 'string' && UnpersistedEntityDummyId.dummyIdRegex.test(candidate)
+	}
+
+	get uniqueValue() {
+		return this.value as UniqueEntityId
+	}
+}
+
+export type RuntimeId = ServerId | ClientGeneratedUuid | UnpersistedEntityDummyId

package/src/consts.ts

@@ -0,0 +1,3 @@
+export const PRIMARY_KEY_NAME = 'id'
+export const TYPENAME_KEY_NAME = '__typename'
+export const NIL_UUID = '00000000-0000-0000-0000-000000000000'

package/src/environment/Environment.ts

@@ -0,0 +1,346 @@
+import { BindingError } from '../BindingError'
+import type { Filter } from '../treeParameters'
+import equal from 'fast-deep-equal/es6/index.js'
+import { Schema, SchemaColumn, SchemaEntity, SchemaRelation } from '../schema'
+import { GraphQlLiteral } from '@contember/client'
+
+class Environment<Node extends Environment.AnyNode | undefined = Environment.AnyNode | undefined> {
+	private constructor(
+		private readonly options: Environment.Options<Node>,
+	) {
+	}
+
+	public static create() {
+		return new Environment({
+			dimensions: {},
+			variables: {},
+			parameters: {},
+			extensions: new Map(),
+		})
+	}
+
+	public getSubTree(): Environment.SubTreeNode {
+		for (let env: Environment = this; env.options.node; env = env.getParent()) {
+			const node = env.options.node
+			if (node.type === 'subtree-entity' || node.type === 'subtree-entity-list') {
+				return node
+			}
+		}
+		throw new BindingError('Not in a SubTree')
+	}
+
+	public getSubTreeNode(): Node & Environment.AnyNode {
+		if (!this.options.node) {
+			throw new BindingError()
+		}
+		return this.options.node
+	}
+
+	public withSubTree<Node extends Environment.SubTreeNode>(SubTree: Node): Environment<Node> {
+		const { parent, ...options } = this.options
+		return new Environment({
+			...options,
+			node: SubTree,
+		})
+	}
+
+	public withSubTreeChild<Node extends Environment.InnerNode>(node: Node): Environment<Node> {
+		if (!this.options.node) {
+			throw new BindingError(`Cannot call withSubTreeChild without previous call of withSubTree`)
+		}
+		if (this.options.node.entity.fields.get(node.field.name) !== node.field) {
+			throw new BindingError()
+		}
+		return new Environment({
+			...this.options,
+			node,
+			parent: this,
+		})
+	}
+
+
+	public hasVariable(key: string): boolean {
+		return key in this.options.variables
+	}
+
+	public getVariable<V extends Environment.Value = Environment.Value>(key: string): V {
+		if (!(key in this.options.variables)) {
+			throw new BindingError(`Variable ${key} not found`)
+		}
+		return this.options.variables[key] as V
+	}
+
+	public getVariableOrElse<F, V extends Environment.Value = Environment.Value>(key: string, fallback: F): V | F {
+		return (this.options.variables[key] as V) ?? fallback
+	}
+
+	/** @deprecated use getVariable or getParameter */
+	public getValue<V extends Environment.Value = Environment.Value>(key: string): V {
+		console.warn('Environment.getValue() is deprecated, use Environment.getVariable() or Environment.getParameter() instead.')
+		return this.getVariableOrElse(key, undefined) ?? this.getParameterOrElse(key, undefined) as V
+	}
+
+	/** @deprecated use getVariableOrElse or getParameterOrElse */
+	public getValueOrElse<F, V extends Environment.Value = Environment.Value>(key: string, fallback: F): V | F {
+		console.warn('Environment.getValueOrElse() is deprecated, use Environment.getVariableOrElse() or Environment.getParameterOrElse() instead.')
+		return this.getVariableOrElse(key, undefined) ?? this.getParameterOrElse(key, fallback) as any
+	}
+
+	/** @deprecated */
+	public hasName(key: string): boolean {
+		console.warn('Environment.hasName() is deprecated, use Environment.hasVariable() or Environment.hasParameter() instead.')
+		return key in this.options.variables || key in this.options.parameters
+	}
+
+	public withVariables(variables: Environment.ValuesMapWithFactory | undefined): Environment {
+		if (variables === undefined) {
+			return this
+		}
+		const newVariables = { ...this.options.variables }
+		for (const [newName, newValue] of Object.entries(variables)) {
+			if (newName === 'labelMiddleware') {
+				throw new BindingError('You cannot pass labelMiddleware to withVariables method. Use withLabelMiddleware instead.')
+			}
+			const resolvedValue = typeof newValue === 'function' ? newValue(this) : newValue
+			if (resolvedValue === undefined) {
+				delete newVariables[newName]
+			} else {
+				newVariables[newName] = resolvedValue
+			}
+		}
+		return new Environment({
+			...this.options,
+			variables: newVariables,
+			parent: this,
+		})
+	}
+
+	public getAllVariables() {
+		return this.options.variables
+	}
+
+	public hasParameter(key: string): boolean {
+		return key in this.options.parameters
+	}
+
+	public getParameter<F>(key: string): string | number {
+		if (!(key in this.options.parameters)) {
+			throw new BindingError(`Parameter ${key} not found`)
+		}
+		return this.options.parameters[key] as string | number
+	}
+
+	public getParameterOrElse<F>(key: string, fallback: F): string | number | F {
+		return this.options.parameters[key] ?? fallback
+	}
+
+	public getAllParameters() {
+		return this.options.parameters
+	}
+
+	public withParameters(parameters: Environment.Parameters): Environment {
+		return new Environment({ ...this.options, parameters })
+	}
+
+	public hasDimension(dimensionName: string): boolean {
+		return dimensionName in this.options.dimensions
+	}
+
+	public getDimension<F>(dimensionName: string): string[] {
+		if (!(dimensionName in this.options.dimensions)) {
+			throw new BindingError(`Dimension ${dimensionName} does not exist.`)
+		}
+		return this.options.dimensions[dimensionName]
+	}
+
+	public getDimensionOrElse<F>(dimensionName: string, fallback: F): string[] | F {
+		return this.options.dimensions[dimensionName] ?? fallback
+	}
+
+	public getAllDimensions(): Environment.SelectedDimensions {
+		return this.options.dimensions
+	}
+
+	public withDimensions(dimensions: Environment.SelectedDimensions): Environment {
+		const newDimensions = {
+			...this.options.dimensions,
+			...dimensions,
+		}
+		if (equal(newDimensions, this.options.dimensions)) {
+			return this
+		}
+		return new Environment({ ...this.options, dimensions: newDimensions })
+	}
+
+	hasSchema(): boolean {
+		return this.options.schema !== undefined
+	}
+
+	public getSchema(): Schema {
+		if (!this.options.schema) {
+			throw new BindingError('Schema is not set')
+		}
+		return this.options.schema
+	}
+
+	public withSchema(schema: Schema): Environment {
+		return new Environment({ ...this.options, schema })
+	}
+
+	public getParent(): Environment {
+		if (!this.options.parent) {
+			throw new BindingError('There is no parent environment')
+		}
+		return this.options.parent
+	}
+
+	public withExtension<S, R>(extension: Environment.Extension<S, R>, state: S): Environment {
+		return new Environment({
+			...this.options,
+			extensions: new Map([...this.options.extensions, [extension, state] as [Environment.Extension<unknown, unknown>, unknown]]),
+		})
+	}
+
+	public getExtension<S, R>(extension: Environment.Extension<S, R>): R {
+		const state = this.options.extensions.get(extension as Environment.Extension<unknown, unknown>)
+		return extension.create(state as S, this)
+	}
+
+	public merge(other: Environment): Environment {
+		if (other === this) {
+			return this
+		}
+		if (!equal(this.options.node, other.options.node)) {
+			throw new BindingError(`Cannot merge two environments with different tree position.`)
+		}
+		if (this.options.parameters !== other.options.parameters) {
+			throw new BindingError(`Cannot merge two environments with different parameters.`)
+		}
+		if (this.options.dimensions !== other.options.dimensions) {
+			throw new BindingError(`Cannot merge two environments with different dimensions.`)
+		}
+		if (this.options.extensions !== other.options.extensions) {
+			// todo: deep compare?
+			throw new BindingError(`Cannot merge two environments with different extensions.`)
+		}
+
+		if (equal(this.options.variables, other.options.variables) && this.options.parent === other.options.parent) {
+			return this
+		}
+		for (const key in other.options.variables) {
+			if (key in this.options.variables && !equal(this.options.variables[key], other.options.variables[key])) {
+				throw new BindingError(`Cannot merge two environments with different value of variable ${key}:\n`
+					+ JSON.stringify(this.options.variables[key]) + '\n'
+					+ JSON.stringify(other.options.variables[key]))
+			}
+		}
+
+		return new Environment({
+			...this.options,
+			parent: this.options.parent && other.options.parent ? this.options.parent.merge(other.options.parent) : undefined,
+			variables: { ...this.options.variables, ...other.options.variables },
+		})
+	}
+}
+
+namespace Environment {
+	export type Name = string
+
+	export type ReactElementLike = {
+		type: any
+		props: any
+	}
+
+	export type Value = string | number | boolean | undefined | GraphQlLiteral | Filter | ReactElementLike
+
+	export type ResolvedValue = Value
+
+	export interface Options<Node extends AnyNode | undefined> {
+		node?: Node
+		schema?: Schema
+		dimensions: SelectedDimensions
+		parameters: Parameters
+		variables: CustomVariables
+		parent?: Environment
+		extensions: Map<Extension<unknown, unknown>, unknown>
+	}
+
+	export type SubTreeNode =
+		| SubTreeEntityNode
+		| SubTreeEntityListNode
+
+	export type InnerNode =
+		| EntityNode
+		| EntityListNode
+		| ColumnNode
+
+	export type AnyNode =
+		| SubTreeNode
+		| InnerNode
+
+	export interface SubTreeEntityNode {
+		type: 'subtree-entity'
+		entity: SchemaEntity
+		expectedCardinality: 'zero' | 'one' | 'zero-or-one'
+		filter: Filter
+	}
+
+	export interface SubTreeEntityListNode {
+		type: 'subtree-entity-list'
+		entity: SchemaEntity
+		expectedCardinality: 'zero-to-many' | 'zero'
+		filter: Filter
+	}
+
+	export interface EntityNode {
+		type: 'entity'
+		entity: SchemaEntity
+		field: SchemaRelation
+	}
+
+	export interface EntityListNode {
+		type: 'entity-list'
+		entity: SchemaEntity
+		field: SchemaRelation
+	}
+
+	export interface ColumnNode {
+		type: 'column'
+		entity: SchemaEntity
+		field: SchemaColumn
+	}
+
+	export interface SelectedDimensions {
+		[key: string]: string[]
+	}
+
+	export type Parameters = {
+		[K in string]?: string | number
+	}
+
+	export interface CustomVariables {
+		[key: string]: Value
+	}
+
+	export interface ValuesMapWithFactory {
+		[key: string]:
+			| ((environment: Environment) => Value)
+			| Value
+	}
+
+	export type Extension<State, Result> = {
+		create: (state: State | undefined, environment: Environment) => Result
+	}
+
+	export const createExtension = <S, R>(create: Extension<S, R>['create'], otherMethods?: Omit<Extension<S, R>, 'create'>): Extension<S, R> => {
+		return {
+			create,
+			...otherMethods,
+		}
+	}
+
+	/** @deprecated */
+	export type DeltaFactory = ValuesMapWithFactory
+}
+
+export { Environment }

package/src/environment/TreeNodeEnvironmentFactory.ts

@@ -0,0 +1,137 @@
+import { Environment } from './Environment'
+import {
+	HasOneRelation,
+	SugaredQualifiedEntityList,
+	SugaredQualifiedSingleEntity,
+	SugaredRelativeEntityList,
+	SugaredRelativeSingleEntity,
+	SugaredRelativeSingleField,
+	SugaredUnconstrainedQualifiedEntityList,
+	SugaredUnconstrainedQualifiedSingleEntity,
+} from '../treeParameters'
+import { QueryLanguage } from '../queryLanguage'
+import { whereToFilter } from '@contember/client'
+import { TreeNodeUtils } from '../utils/TreeNodeUtils'
+
+export class TreeNodeEnvironmentFactory {
+
+	public static createEnvironmentForEntityListSubtree(
+		environment: Environment,
+		sugaredEntityList: SugaredQualifiedEntityList | SugaredUnconstrainedQualifiedEntityList,
+	): Environment {
+		let entityList
+		let rootWhere
+		let expectedCardinality: Environment.SubTreeNode['expectedCardinality']
+
+		if (sugaredEntityList.isCreating) {
+			entityList = QueryLanguage.desugarUnconstrainedQualifiedEntityList(sugaredEntityList, environment)
+			rootWhere = {} as const
+			expectedCardinality = 'zero'
+
+		} else {
+			entityList = QueryLanguage.desugarQualifiedEntityList(sugaredEntityList, environment)
+			rootWhere = entityList.filter ?? {}
+			expectedCardinality = 'zero-to-many'
+		}
+
+		const entitySchema = TreeNodeUtils.resolveEntity(environment.getSchema(), entityList.entityName, 'entity list')
+
+		return environment.withSubTree({
+			type: 'subtree-entity-list',
+			entity: entitySchema,
+			expectedCardinality,
+			filter: rootWhere,
+		})
+	}
+
+	public static createEnvironmentForEntitySubtree(
+		environment: Environment,
+		sugaredEntityList: SugaredQualifiedSingleEntity | SugaredUnconstrainedQualifiedSingleEntity,
+	): Environment {
+		let entity
+		let rootWhere
+		let expectedCardinality: Environment.SubTreeNode['expectedCardinality']
+
+		if (sugaredEntityList.isCreating) {
+			rootWhere = { } as const
+			expectedCardinality = 'zero'
+			entity = QueryLanguage.desugarUnconstrainedQualifiedSingleEntity(sugaredEntityList, environment)
+
+		} else {
+			entity = QueryLanguage.desugarQualifiedSingleEntity(sugaredEntityList, environment, { missingSetOnCreate: 'fill' })
+			rootWhere = whereToFilter(entity.where)
+			expectedCardinality = entity.setOnCreate ? 'zero-or-one' : 'one'
+		}
+
+		const entitySchema = TreeNodeUtils.resolveEntity(environment.getSchema(), entity.entityName, 'entity')
+
+		return environment.withSubTree({
+			type: 'subtree-entity',
+			entity: entitySchema,
+			expectedCardinality: expectedCardinality,
+			filter: rootWhere,
+		})
+	}
+
+	public static createEnvironmentForEntityList(
+		environment: Environment,
+		sugaredRelativeEntityList: SugaredRelativeEntityList,
+	): Environment {
+		const relativeEntityList = QueryLanguage.desugarRelativeEntityList(sugaredRelativeEntityList, environment)
+		const hasOneEnvironment = this.traverseHasOnePath(environment, relativeEntityList.hasOneRelationPath)
+		const hasManyField = relativeEntityList.hasManyRelation.field
+
+		const field = TreeNodeUtils.resolveHasManyRelation(hasOneEnvironment, hasManyField)
+
+		const targetEntity = environment.getSchema().getEntity(field.targetEntity)
+
+		return hasOneEnvironment.withSubTreeChild({
+			type: 'entity-list',
+			field,
+			entity: targetEntity,
+		})
+	}
+
+	public static createEnvironmentForEntity(
+		environment: Environment,
+		sugaredRelativeSingleEntity: SugaredRelativeSingleEntity,
+	) {
+		const relativeSingleEntity = QueryLanguage.desugarRelativeSingleEntity(sugaredRelativeSingleEntity, environment)
+
+		return this.traverseHasOnePath(environment, relativeSingleEntity.hasOneRelationPath)
+	}
+
+	public static createEnvironmentForField(
+		environment: Environment,
+		sugaredRelativeSingleField: SugaredRelativeSingleField,
+	) {
+		const relativeSingleField = QueryLanguage.desugarRelativeSingleField(sugaredRelativeSingleField, environment)
+		const hasOneEnvironment = this.traverseHasOnePath(environment, relativeSingleField.hasOneRelationPath)
+
+		const field = TreeNodeUtils.resolveColumn(hasOneEnvironment, relativeSingleField.field)
+
+		return hasOneEnvironment.withSubTreeChild({
+			type: 'column',
+			entity: environment.getSubTreeNode().entity,
+			field,
+		})
+	}
+
+	private static traverseHasOnePath(
+		environment: Environment,
+		hasOneRelationPath: HasOneRelation[],
+	): Environment {
+		for (const pathItem of hasOneRelationPath) {
+			const field = TreeNodeUtils.resolveHasOneRelation(environment, pathItem.field, !!pathItem.reducedBy)
+			const targetEntity = environment.getSchema().getEntity(field.targetEntity)
+
+			environment = environment.withSubTreeChild({
+				type: 'entity',
+				field,
+				entity: targetEntity,
+			})
+		}
+		return environment
+	}
+
+}

package/src/environment/VariableFieldValue.ts

@@ -0,0 +1,3 @@
+export class VariableFieldValue {
+	public constructor(public readonly variableName: string) {}
+}

package/src/environment/VariableInputTransformer.ts

@@ -0,0 +1,27 @@
+import type { FieldValue, OptionallyVariableFieldValue } from '../treeParameters'
+import { VariableFieldValue } from './VariableFieldValue'
+import { Environment } from './Environment'
+import { BindingError } from '../BindingError'
+
+export class VariableInputTransformer {
+	public static transformValue(value: OptionallyVariableFieldValue, environment: Environment): FieldValue {
+		if (value instanceof VariableFieldValue) {
+			return VariableInputTransformer.transformVariableFieldValue(value, environment)
+		}
+		return value
+	}
+
+	public static transformVariableFieldValue(variableFieldValue: VariableFieldValue, environment: Environment): FieldValue {
+		const value = environment.getVariableOrElse(variableFieldValue.variableName, undefined)
+			?? environment.getParameterOrElse(variableFieldValue.variableName, undefined)
+
+		if (value === undefined) {
+			throw new BindingError(`Variable '${variableFieldValue.variableName}' not found.`)
+		}
+
+		if (typeof value !== 'string' && typeof value !== 'boolean' && typeof value !== 'number' && value !== null) {
+			throw new BindingError(`The value of the '${variableFieldValue.variableName}' must be a scalar or null, not '${typeof value}'.`)
+		}
+		return value
+	}
+}

package/src/environment/index.ts

@@ -0,0 +1,4 @@
+export * from './Environment'
+export * from './TreeNodeEnvironmentFactory'
+export * from './VariableFieldValue'
+export * from './VariableInputTransformer'

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from './markers'
+export * from './treeParameters'
+export * from './environment'
+export * from './queryLanguage'
+export * from './schema'
+export * from './types'
+
+export * from './consts'
+export * from './BindingError'
+export * from './DataBindingExtendAborted'
+export * from './LocalizedBindingError'
+export * from './RuntimeId'
+export * from './utils/TreeNodeUtils'
+export * from './utils/assertNever'
+export * from './utils/createQueryBuilder'
+
+export { v4 as generateUuid } from 'uuid'

package/src/markers/EntityFieldMarkers.ts

@@ -0,0 +1,7 @@
+import type { PlaceholderName } from '../treeParameters'
+import type { FieldMarker } from './FieldMarker'
+import type { HasManyRelationMarker } from './HasManyRelationMarker'
+import type { HasOneRelationMarker } from './HasOneRelationMarker'
+
+export type EntityFieldMarker = FieldMarker | HasOneRelationMarker | HasManyRelationMarker
+export type EntityFieldMarkers = ReadonlyMap<PlaceholderName, EntityFieldMarker>

package/src/markers/EntityFieldMarkersContainer.ts

@@ -0,0 +1,10 @@
+import type { EntityFieldMarkers } from './EntityFieldMarkers'
+import type { EntityFieldPlaceholders } from './EntityFieldPlaceholders'
+
+export class EntityFieldMarkersContainer {
+	public constructor(
+		public readonly hasAtLeastOneBearingField: boolean,
+		public readonly markers: EntityFieldMarkers, // Indexed by placeholder names
+		public readonly placeholders: EntityFieldPlaceholders, // Indexed by field names
+	) {}
+}

package/src/markers/EntityFieldPlaceholders.ts

@@ -0,0 +1,3 @@
+import type { FieldName, PlaceholderName } from '../treeParameters'
+
+export type EntityFieldPlaceholders = ReadonlyMap<FieldName, PlaceholderName | Set<PlaceholderName>>

package/src/markers/EntityFieldsWithHoistablesMarker.ts

@@ -0,0 +1,11 @@
+import type { ParentEntityParameters } from '../treeParameters'
+import type { EntityFieldMarkersContainer } from './EntityFieldMarkersContainer'
+import type { SubTreeMarkers } from './SubTreeMarkers'
+
+export class EntityFieldsWithHoistablesMarker {
+	public constructor(
+		public readonly fields: EntityFieldMarkersContainer,
+		public readonly subTrees: SubTreeMarkers | undefined,
+		public readonly parentReference: ParentEntityParameters | undefined,
+	) {}
+}

package/src/markers/EntityListSubTreeMarker.ts

@@ -0,0 +1,20 @@
+import type { Environment } from '../environment'
+import type { QualifiedEntityList, UnconstrainedQualifiedEntityList } from '../treeParameters'
+import type { EntityFieldMarkersContainer } from './EntityFieldMarkersContainer'
+import { PlaceholderGenerator } from './PlaceholderGenerator'
+
+export class EntityListSubTreeMarker {
+	public readonly placeholderName: string
+
+	public constructor(
+		public readonly parameters: QualifiedEntityList | UnconstrainedQualifiedEntityList,
+		public readonly fields: EntityFieldMarkersContainer,
+		public readonly environment: Environment,
+	) {
+		this.placeholderName = PlaceholderGenerator.getEntityListSubTreePlaceholder(this.parameters, this.environment)
+	}
+
+	public get entityName() {
+		return this.parameters.entityName
+	}
+}

package/src/markers/EntitySubTreeMarker.ts

@@ -0,0 +1,20 @@
+import type { Environment } from '../environment'
+import type { QualifiedSingleEntity, UnconstrainedQualifiedSingleEntity } from '../treeParameters'
+import type { EntityFieldMarkersContainer } from './EntityFieldMarkersContainer'
+import { PlaceholderGenerator } from './PlaceholderGenerator'
+
+export class EntitySubTreeMarker {
+	public readonly placeholderName: string
+
+	public constructor(
+		public readonly parameters: QualifiedSingleEntity | UnconstrainedQualifiedSingleEntity,
+		public readonly fields: EntityFieldMarkersContainer,
+		public readonly environment: Environment,
+	) {
+		this.placeholderName = PlaceholderGenerator.getEntitySubTreePlaceholder(this.parameters, this.environment)
+	}
+
+	public get entityName() {
+		return this.parameters.entityName
+	}
+}