@contember/engine-content-api 1.2.0-alpha.9 → 1.2.0-beta.1

package/tests/cases/integration/graphQlRequests/update/oneHasOneInverse/delete.test.ts

@@ -22,12 +22,12 @@ test('delete', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."site" as "root_" where "root_"."setting_id" = ?`,
+					parameters: [testUuid(2)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."site" as "root_" where "root_"."setting_id" = ?`,
-						parameters: [testUuid(2)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."site"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlSchema/graphQlSchemaBuilder.test.ts

@@ -1,7 +1,7 @@
 import { graphql, printSchema } from 'graphql'
 import { Acl, Model } from '@contember/schema'
-import * as path from 'path'
-
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
 import {
 	AllowAllPermissionFactory,
 	SchemaBuilder,
@@ -10,7 +10,6 @@ import {
 } from '@contember/schema-definition'
 import { Authorizator, GraphQlSchemaBuilderFactory } from '../../../../src'
 import * as model from './model'
-import { promises as fs } from 'fs'
 import { assert, describe, it } from 'vitest'
 
 interface Test {

package/tests/cases/unit/predicatesFactory.test.ts

@@ -76,8 +76,14 @@ describe('Predicates factory', () => {
 	it('eliminates a predicate', () => {
 		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}))
 		const image = schema.entities['Image']
-		const authorRelation = image.fields['authors'] as Model.AnyRelation
-		const predicate = predicateFactory.create(image, Acl.Operation.read, undefined, authorRelation)
+		const authorRelation = image.fields['authors'] as Model.OneHasManyRelation
+		const predicate = predicateFactory.create(image, Acl.Operation.read, undefined, {
+			type: 'manyHasOne',
+			entity: schema.entities.Author,
+			relation: schema.entities.Author.fields.image as Model.ManyHasOneRelation,
+			targetEntity: image,
+			targetRelation: authorRelation,
+		})
 		assert.deepStrictEqual(predicate, {
 			or: [
 				{

package/tests/cases/unit/predicatesInjector.test.ts

@@ -1,7 +1,12 @@
-import { PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { PermissionFactory, PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
+import { SchemaBuilder, SchemaDefinition as def, AclDefinition as acl, createSchema } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it, assert } from 'vitest'
+import { PermissionsFactory } from '@contember/engine-system-api/dist/src/model'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { testUuid } from '@contember/engine-api-tester'
 
 
 
@@ -45,6 +50,7 @@ const permissions: Acl.Permissions = {
 	},
 }
 
+
 describe('Predicates injector', () => {
 
 	const variables: Acl.VariablesMap = {
@@ -107,5 +113,94 @@ describe('Predicates injector', () => {
 			],
 		})
 	})
+
+
 })
 
+namespace DeepFilterModel {
+	export const readerRole = acl.createRole('reader')
+
+	@acl.allow(readerRole, {
+		when: { isPublished: { eq: true } },
+		read: ['coverPhoto'],
+	})
+	export class Article {
+		isPublished = def.boolColumn()
+		title = def.stringColumn()
+		coverPhoto = def.manyHasOne(ImageUse, 'articles')
+	}
+
+	@acl.allow(readerRole, {
+		when: { articles: acl.canRead('coverPhoto') },
+		read: true,
+	})
+	export class ImageUse {
+		articles = def.oneHasMany(Article, 'coverPhoto')
+		image = def.manyHasOne(Image, 'uses')
+	}
+
+	@acl.allow(readerRole, {
+		when: { uses: acl.canRead('image') },
+		read: true,
+	})
+	export class Image {
+		uses = def.oneHasMany(ImageUse, 'image')
+		url = def.stringColumn()
+		tags = def.manyHasMany(Tag)
+	}
+
+	@acl.allow(readerRole, {
+		read: true,
+	})
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+describe('predicates injector elimination', () => {
+	const schema = createSchema(DeepFilterModel)
+	const permissions = new PermissionFactory(schema.model).create(schema.acl, ['reader'])
+
+	const injector = new PredicatesInjector(
+		schema.model,
+		new PredicateFactory(permissions, schema.model, new VariableInjector(schema.model, {})),
+	)
+	it('eliminates predicates in where', () => {
+		const injected = injector.inject(schema.model.entities.Article, {
+			coverPhoto: { image: { tags: { label: { eq: 'foo' } } } },
+		})
+		const optimizer = new WhereOptimizer(schema.model, new ConditionOptimizer())
+		const result = optimizer.optimize(injected, schema.model.entities.Article)
+
+		assert.deepStrictEqual(result, { and: [{ coverPhoto: { image: { tags: { label: { eq: 'foo' } } } } }, { isPublished: { eq: true } }] })
+	})
+
+	it('eliminate back referencing predicate', () => {
+		const relation = acceptFieldVisitor(schema.model, schema.model.entities.Article, 'coverPhoto', {
+			visitColumn: () => {
+				throw new Error()
+			},
+			visitRelation: ctx => ctx,
+		})
+		const injected = injector.inject(schema.model.entities.ImageUse, {
+			articles: { id: { in: [testUuid(1)] } },
+		}, relation)
+
+		assert.deepStrictEqual(injected, {
+			and: [
+				{
+					articles: {
+						and: [
+							{ id: { in: [testUuid(1)] } },
+							{ id: { always: true } },
+						],
+					},
+				},
+				{
+					articles: { id: { always: true } },
+				},
+			],
+		})
+	})
+})

package/tests/cases/unit/whereBuilder.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, assert } from 'vitest'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { ConditionBuilder, JoinBuilder, PathFactory, WhereBuilder } from '../../../src/mapper'
+import { Compiler, SelectBuilder } from '@contember/database'
+import { Input, Schema } from '@contember/schema'
+
+namespace WhereBuilderModel {
+	export class Author {
+		name = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		articles = def.oneHasMany(Article, 'author')
+	}
+
+	export class Article {
+		title = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		author = def.manyHasOne(Author, 'articles')
+		tags = def.manyHasMany(Tag)
+	}
+
+	export class Tag {
+		name = def.stringColumn()
+	}
+}
+
+const createWhere = (schema: Schema, where: Input.Where) => {
+	const pathFactory = new PathFactory()
+	const joinBuilder = new JoinBuilder(schema.model)
+	const conditionBuilder = new ConditionBuilder()
+	const whereOptimizer = new WhereOptimizer(schema.model, new ConditionOptimizer())
+	const whereBuilder = new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimizer, schema.settings.useExistsInHasManyFilter === true)
+
+	const qb = SelectBuilder.create()
+		.from('author', 'root_')
+
+	return whereBuilder.build(qb, schema.model.entities.Author, pathFactory.create([]), where).options.where.compile().sql
+}
+
+describe('where builder', () => {
+	it('where on has-many relation with AND outside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			and: [
+				{
+					articles: { isPublic: { eq: true } },
+				},
+				{
+					articles: { title: { eq: 'Hello' } },
+				},
+			],
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."is_public" = ?) and exists (select 1  from "__SCHEMA__"."article" as "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."title" = ?)',
+		)
+	})
+
+	it('where on has-many relation with AND inside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ isPublic: { eq: true } },
+					{ title: { eq: 'Hello' } },
+				],
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."is_public" = ? and "root_articles"."title" = ?)',
+		)
+	})
+
+
+	it('where on has-many relation with isNull', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				id: { isNull: true },
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from (select "root_"."id") as "root_articles_tmp_" left join  "__SCHEMA__"."article" as "root_articles" on  "root_articles_tmp_"."id" = "root_articles"."author_id"  where "root_articles"."id" is null)',
+		)
+	})
+
+	it('where with nested has-many', () => {
+		const schema: Schema = { ...createSchema(WhereBuilderModel), settings: { useExistsInHasManyFilter: true } }
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ tags: { name: { eq: 'Hello' } } },
+					{ tags: { name: { eq: 'World' } } },
+				],
+			},
+		})
+		compareWhere(
+			where,
+			`where exists (select 1
+				from "__SCHEMA__"."article" as "root_articles"
+				where "root_"."id" = "root_articles"."author_id"
+					and exists (select 1
+						from "__SCHEMA__"."article_tags" as "root_articles_tags_junction_"
+						inner join  "__SCHEMA__"."tag" as "root_articles_tags" on  "root_articles_tags_junction_"."tag_id" = "root_articles_tags"."id"
+						where "root_articles"."id" = "root_articles_tags_junction_"."article_id" and "root_articles_tags"."name" = ?)
+					and exists (select 1
+						from "__SCHEMA__"."article_tags" as "root_articles_tags_junction_"
+						inner join  "__SCHEMA__"."tag" as "root_articles_tags" on  "root_articles_tags_junction_"."tag_id" = "root_articles_tags"."id"
+						where "root_articles"."id" = "root_articles_tags_junction_"."article_id" and "root_articles_tags"."name" = ?))`,
+		)
+	})
+
+
+	it('where without nested has-many', () => {
+		const schema: Schema = { ...createSchema(WhereBuilderModel) }
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ tags: { name: { eq: 'Hello' } } },
+					{ tags: { name: { eq: 'World' } } },
+				],
+			},
+		})
+		compareWhere(
+			where,
+			`where exists (select 1
+				from "__SCHEMA__"."article" as "root_articles"
+				left join "__SCHEMA__"."article_tags" as "root_articles_x_root_articles_tags" on "root_articles"."id" = "root_articles_x_root_articles_tags"."article_id"
+				left join "__SCHEMA__"."tag" as "root_articles_tags" on "root_articles_x_root_articles_tags"."tag_id" = "root_articles_tags"."id"
+				where "root_"."id" = "root_articles"."author_id" and "root_articles_tags"."name" = ? and "root_articles_tags"."name" = ?)`,
+		)
+	})
+})
+
+
+const compareWhere = (actual: string, expected: string) => {
+	const normalize = (s: string) => s.replaceAll(/\s+/g, ' ').trim()
+	try {
+		assert.equal(normalize(actual), normalize(expected))
+	} catch (e) {
+		console.log(normalize(actual))
+		console.log(normalize(expected))
+		throw e
+	}
+}

package/tests/cases/unit/whereOptimizer.test.ts

@@ -2,18 +2,21 @@ import { describe, it, assert } from 'vitest'
 import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
 
 namespace TestModel {
 	export class Author {
 		name = def.stringColumn()
 		isPublic = def.boolColumn().notNull()
 		image = def.manyHasOne(Image, 'authors')
+		articles = def.oneHasMany(Article, 'author')
 	}
 
 	export class Article {
 		title = def.stringColumn()
 		isPublic = def.boolColumn().notNull()
 		image = def.manyHasOne(Image, 'articles')
+		author = def.manyHasOne(Author, 'articles')
 	}
 
 	export class Image {
@@ -90,4 +93,200 @@ describe('where optimized', () => {
 		},
 		)
 	})
+
+
+	const A = { authors: { isPublic: { eq: true } } }
+	const B = { authors: { name: { eq: 'John' } } }
+	const C = { authors: { name: { eq: 'Jack' } } }
+
+	it('minimize: A || (A && B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A && B) || A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (A || B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A || B) && A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ or: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (!A || B) => A && B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { and: [A, B] })
+	})
+
+	it('minimize: A || (!A && B) => A || B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { or: [A, B] })
+	})
+
+
+	it('minimize: A || !A => 1', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { always: true } })
+	})
+
+	it('minimize: A && !A => 0', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { never: true } })
+	})
+
+	it('minimize: !A && !A => !A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ not: A },
+				{ not: A },
+			],
+		}, model.entities.Image), { not: A })
+	})
+
+
+	it('not minimize: (A && B) || (A && C)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		}, model.entities.Image), {
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		})
+	})
+
+
+	describe('remove id predicates', () => {
+
+		it('remove ID predicate when traversing from a relation - always', () => {
+			const relationPath = [acceptFieldVisitor(model, 'Image', 'authors', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { id: { isNull: false } },
+			}, model.entities.Author, { relationPath }), {
+				id: { always: true },
+			})
+		})
+
+
+		it('remove ID predicate when traversing from a relation - never', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { id: { isNull: true } },
+			}, model.entities.Author, { relationPath: [acceptFieldVisitor(model, 'Image', 'authors', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})] }), {
+				id: { never: true },
+			})
+		})
+
+		it('remove ID predicate when traversing in where', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				authors: { image: { id: { isNull: false } } },
+			}, model.entities.Image), {
+				id: { always: true },
+			})
+		})
+
+		it('do not remove ID predicate when traversing from a has-many relation', () => {
+			const relationPath = [acceptFieldVisitor(model, 'Author', 'image', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				authors: { id: { isNull: false } },
+			}, model.entities.Image, { relationPath }), {
+				authors: { id: { isNull: false } },
+			})
+		})
+
+		it('do not remove ID predicate when traversing from a nested has-many relation', () => {
+			const relationPath = [
+				acceptFieldVisitor(model, 'Author', 'articles', {
+					visitColumn: () => {
+						throw new Error()
+					},
+					visitRelation: context => context,
+				}),
+				acceptFieldVisitor(model, 'Article', 'image', {
+					visitColumn: () => {
+						throw new Error()
+					},
+					visitRelation: context => context,
+				}),
+			]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				articles: { author: { id: { isNull: false } } },
+			}, model.entities.Image, { relationPath }), {
+				articles: { author: { id: { isNull: false } } },
+			})
+		})
+
+		it('do not remove ID predicate when traversing in where over has-many relation', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { authors: { id: { isNull: false } } },
+			}, model.entities.Author), {
+				image: { authors: { id: { isNull: false } } },
+			})
+		})
+
+
+		it('do not remove ID predicate when traversing in where over has-many relation - nested', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { authors: { image: { id: { isNull: false } } } },
+			}, model.entities.Author), {
+				image: { authors: { image: { id: { isNull: false } } } },
+			})
+		})
+	})
 })
+

package/tests/src/test.ts

@@ -1,11 +1,11 @@
 import { Acl, Model, Schema, Validation } from '@contember/schema'
-import { ExecutionContainerFactory, GraphQlSchemaBuilderFactory, Authorizator } from '../../src'
+import { Authorizator, ExecutionContainerFactory, GraphQlSchemaBuilderFactory } from '../../src'
 import { AllowAllPermissionFactory, emptySchema } from '@contember/schema-utils'
 import { executeGraphQlTest } from './testGraphql'
 import { Client } from '@contember/database'
 import { createConnectionMock } from '@contember/database-tester'
 import { createUuidGenerator } from '@contember/engine-api-tester'
-import { getArgumentValues } from 'graphql/execution/values'
+import { getArgumentValues } from 'graphql'
 import { SQL } from './tags'
 
 export interface SqlQuery {

package/tests/src/testGraphql.ts

@@ -1,3 +1,4 @@
+import { NullLoggerHandler, withLogger, createLogger } from '@contember/logger'
 import { graphql, GraphQLSchema } from 'graphql'
 import { assert } from 'vitest'
 
@@ -10,11 +11,14 @@ export interface Test {
 }
 
 export const executeGraphQlTest = async (test: Test) => {
-	const rawResponse = await graphql({
-		schema: test.schema,
-		source: test.query,
-		contextValue: test.context,
-		variableValues: test.queryVariables,
+	const logger = createLogger(new NullLoggerHandler())
+	const rawResponse = await withLogger(logger, () => {
+		return graphql({
+			schema: test.schema,
+			source: test.query,
+			contextValue: test.context,
+			variableValues: test.queryVariables,
+		})
 	})
 	const response = JSON.parse(JSON.stringify(rawResponse))
 	if ('errors' in rawResponse) {

package/dist/src/inputProcessing/InputContext.d.ts

@@ -1,43 +0,0 @@
-import { Input, Model } from '@contember/schema';
-export interface ColumnContext {
-    entity: Model.Entity;
-    column: Model.AnyColumn;
-    input: Input.ColumnValue | undefined;
-}
-export interface ManyHasManyInverseContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasManyInverseRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasManyOwningRelation;
-}
-export interface ManyHasManyOwningContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasManyOwningRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasManyInverseRelation | null;
-}
-export interface ManyHasOneContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasOneRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasManyRelation | null;
-}
-export interface OneHasManyContext {
-    entity: Model.Entity;
-    relation: Model.OneHasManyRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasOneRelation;
-}
-export interface OneHasOneInverseContext {
-    entity: Model.Entity;
-    relation: Model.OneHasOneInverseRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasOneOwningRelation;
-}
-export interface OneHasOneOwningContext {
-    entity: Model.Entity;
-    relation: Model.OneHasOneOwningRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasOneInverseRelation | null;
-}
-//# sourceMappingURL=InputContext.d.ts.map

package/dist/src/inputProcessing/InputContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InputContext.d.ts","sourceRoot":"","sources":["../../../src/inputProcessing/InputContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEhD,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,MAAM,EAAE,KAAK,CAAC,SAAS,CAAA;IACvB,KAAK,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAA;CACpC;AAED,MAAM,WAAW,yBAAyB;IACzC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,0BAA0B,CAAA;IAC1C,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,yBAAyB,CAAA;CAC/C;AAED,MAAM,WAAW,wBAAwB;IACxC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,yBAAyB,CAAA;IACzC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,0BAA0B,GAAG,IAAI,CAAA;CACvD;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,kBAAkB,CAAA;IAClC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAA;CAC/C;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,kBAAkB,CAAA;IAClC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,kBAAkB,CAAA;CACxC;AAED,MAAM,WAAW,uBAAuB;IACvC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,wBAAwB,CAAA;IACxC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,uBAAuB,CAAA;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,uBAAuB,CAAA;IACvC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAA;CACrD"}

package/dist/src/inputProcessing/InputContext.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=InputContext.js.map

package/dist/src/inputProcessing/InputContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InputContext.js","sourceRoot":"","sources":["../../../src/inputProcessing/InputContext.ts"],"names":[],"mappings":""}

package/src/inputProcessing/InputContext.ts

@@ -1,49 +0,0 @@
-import { Input, Model } from '@contember/schema'
-
-export interface ColumnContext {
-	entity: Model.Entity
-	column: Model.AnyColumn
-	input: Input.ColumnValue | undefined
-}
-
-export interface ManyHasManyInverseContext {
-	entity: Model.Entity
-	relation: Model.ManyHasManyInverseRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasManyOwningRelation
-}
-
-export interface ManyHasManyOwningContext {
-	entity: Model.Entity
-	relation: Model.ManyHasManyOwningRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasManyInverseRelation | null
-}
-
-export interface ManyHasOneContext {
-	entity: Model.Entity
-	relation: Model.ManyHasOneRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasManyRelation | null
-}
-
-export interface OneHasManyContext {
-	entity: Model.Entity
-	relation: Model.OneHasManyRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasOneRelation
-}
-
-export interface OneHasOneInverseContext {
-	entity: Model.Entity
-	relation: Model.OneHasOneInverseRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasOneOwningRelation
-}
-
-export interface OneHasOneOwningContext {
-	entity: Model.Entity
-	relation: Model.OneHasOneOwningRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasOneInverseRelation | null
-}