@contember/engine-content-api 1.3.6 → 1.4.0-alpha.2

package/graphql.codegen.yml

@@ -1,5 +1,5 @@
 schema:
-  - "./src/introspection/content-schema.graphql.ts"
+  - "./src/introspection/IntrospectionSchemaDefinitionFactory.ts"
 documents: []
 config:
   immutableTypes: "1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.6",
+  "version": "1.4.0-alpha.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,20 +13,19 @@
     "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/database": "1.3.6",
-    "@contember/dic": "1.3.6",
-    "@contember/graphql-utils": "1.3.6",
-    "@contember/logger": "1.3.6",
-    "@contember/schema": "1.3.6",
-    "@contember/schema-definition": "1.3.6",
-    "@contember/schema-utils": "1.3.6",
-    "fast-deep-equal": "^3.1.3",
-    "graphql-tag": "^2.12.5"
+    "@contember/database": "1.4.0-alpha.2",
+    "@contember/dic": "1.4.0-alpha.2",
+    "@contember/graphql-utils": "1.4.0-alpha.2",
+    "@contember/logger": "1.4.0-alpha.2",
+    "@contember/schema": "1.4.0-alpha.2",
+    "@contember/schema-definition": "1.4.0-alpha.2",
+    "@contember/schema-utils": "1.4.0-alpha.2",
+    "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "1.3.6",
-    "@contember/engine-api-tester": "1.3.6",
-    "@contember/schema-definition": "1.3.6",
+    "@contember/database-tester": "1.4.0-alpha.2",
+    "@contember/engine-api-tester": "1.4.0-alpha.2",
+    "@contember/schema-definition": "1.4.0-alpha.2",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/ExecutionContainer.ts

@@ -27,8 +27,8 @@ import {
 } from './mapper'
 import { Builder } from '@contember/dic'
 import { Acl, Model, Schema } from '@contember/schema'
-import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
-import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { Client, DatabaseMetadata, SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
@@ -44,7 +44,7 @@ import {
 
 export type ExecutionContainerArgs = {
 	schema: Schema & { id: number }
-	schemaDatabaseMetadata: SchemaDatabaseMetadata
+	schemaDatabaseMetadata: DatabaseMetadata
 	db: Client
 	identityId: string
 	identityVariables: Acl.VariablesMap
@@ -107,13 +107,20 @@ export class ExecutionContainerFactory {
 			.addService('whereOptimized', ({ schema }) =>
 				new WhereOptimizer(schema.model, new ConditionOptimizer()))
 			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
-				new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
+				new WhereBuilder(
+					schema.model,
+					joinBuilder,
+					conditionBuilder,
+					pathFactory,
+					whereOptimized,
+					(schema.settings.content?.useExistsInHasManyFilter ?? schema.settings.useExistsInHasManyFilter) === true,
+				))
 			.addService('orderByBuilder', ({ joinBuilder, schema }) =>
 				new OrderByBuilder(schema.model, joinBuilder))
 			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
 				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
-			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, whereBuilder, schema }) =>
-				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, whereBuilder))
+			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, schema }) =>
+				new FieldsVisitorFactory(relationFetcher, predicateFactory, schema.settings.content ?? {}))
 			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
 				new MetaHandler(whereBuilder, predicateFactory))
 			.addService('uniqueWhereExpander', ({ schema }) =>

package/src/extensions/EntityFieldsProvider.ts

@@ -2,7 +2,7 @@ import { GraphQLFieldConfig } from 'graphql'
 import { Model } from '@contember/schema'
 
 export interface EntityFieldsProvider<ExtensionArg extends object = {}> {
-	getFields(entity: Model.Entity, accessibleFields: string[]): FieldMap<ExtensionArg>
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<ExtensionArg>
 }
 
 export type FieldMap<ExtensionArg extends object> = {

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducer.ts

@@ -11,11 +11,18 @@ export class HasManyToHasOneReducer implements EntityFieldsProvider<HasManyToHas
 		private readonly visitor: HasManyToHasOneRelationReducerFieldVisitor,
 	) {}
 
-	getFields(entity: Model.Entity, fields: string[]): FieldMap<HasManyToHasOneReducerExtension> {
-		return fields.reduce(
-			(result, field) => ({ ...result, ...acceptFieldVisitor(this.schema, entity, field, this.visitor) }),
-			{},
-		)
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<HasManyToHasOneReducerExtension> {
+		const fieldMap: FieldMap<HasManyToHasOneReducerExtension> = {}
+		for (const field of accessibleFields) {
+			if (field.type !== Model.RelationType.OneHasMany) {
+				continue
+			}
+
+			for (const [name, resultField] of acceptFieldVisitor(this.schema, entity, field, this.visitor)) {
+				fieldMap[name] = resultField
+			}
+		}
+		return fieldMap
 	}
 }
 

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -1,21 +1,22 @@
 import { GraphQLInputObjectType, GraphQLNonNull } from 'graphql'
 import { Acl, Model } from '@contember/schema'
-import {
-	aliasAwareResolver,
-	EntityTypeProvider,
-	FieldAccessVisitor,
-	GqlTypeName,
-	WhereTypeProvider,
-} from '../../schema'
+import { aliasAwareResolver, EntityTypeProvider, FieldAccessVisitor, GqlTypeName, WhereTypeProvider } from '../../schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Authorizator } from '../../acl'
 import { getFieldsForUniqueWhere } from '../../utils'
-import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
-import { FieldMap } from '../EntityFieldsProvider'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
+import { GraphQLFieldConfig } from 'graphql'
+
+type Result = [
+	string,
+	GraphQLFieldConfig<any, any> & {
+		extensions: HasManyToHasOneReducerExtension
+	}
+]
 
 export class HasManyToHasOneRelationReducerFieldVisitor implements
-	Model.ColumnVisitor<FieldMap<HasManyToHasOneReducerExtension>>,
-	Model.RelationByTypeVisitor<FieldMap<HasManyToHasOneReducerExtension>> {
+	Model.ColumnVisitor<Result[]>,
+	Model.RelationByTypeVisitor<Result[]> {
 
 	constructor(
 		private readonly schema: Model.Schema,
@@ -25,32 +26,32 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 	) {}
 
 	public visitColumn() {
-		return {}
+		return []
 	}
 
 	public visitOneHasOneOwning() {
-		return {}
+		return []
 	}
 
 	public visitOneHasOneInverse() {
-		return {}
+		return []
 	}
 
 	public visitManyHasOne() {
-		return {}
+		return []
 	}
 
 	public visitManyHasManyInverse() {
-		return {}
+		return []
 	}
 
 	public visitManyHasManyOwning() {
-		return {}
+		return []
 	}
 
 	public visitOneHasMany({ entity, targetEntity, targetRelation, relation }: Model.OneHasManyContext) {
 		if (!targetRelation) {
-			return {}
+			return []
 		}
 		const uniqueConstraints = getFieldsForUniqueWhere(this.schema, targetEntity)
 		const composedUnique = uniqueConstraints
@@ -63,6 +64,8 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 			.map(fields => fields[0])
 			.filter(it => it !== targetRelation.name)
 
+
+		const existing = new Set<string>()
 		return [...composedUnique, ...singleUnique]
 			.filter(field =>
 				acceptFieldVisitor(
@@ -72,7 +75,11 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 					new FieldAccessVisitor(Acl.Operation.read, this.authorizator),
 				),
 			)
-			.reduce<FieldMap<HasManyToHasOneReducerExtension>>((fields, fieldName) => {
+			.map<Result | null>(fieldName => {
+				if (existing.has(fieldName)) {
+					return null
+				}
+				existing.add(fieldName)
 				const graphQlName = relation.name + GqlTypeName`By${fieldName}`
 				const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
 					//todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
@@ -84,12 +91,13 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 
 				const entityType = this.entityTypeProvider.getEntity(targetEntity.name)
 
-				return {
-					...fields,
-					[graphQlName]: {
+				return [
+					graphQlName,
+					{
 						type: entityType,
 						extensions: {
 							relationName: relation.name,
+							extensionKey: HasManyToHasOneReducer.extensionName,
 						},
 						args: {
 							by: { type: new GraphQLNonNull(uniqueWhere) },
@@ -97,7 +105,8 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 						},
 						resolve: aliasAwareResolver,
 					},
-				}
-			}, {})
+				]
+			})
+			.filter((it): it is Result => it !== null)
 	}
 }

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProvider.ts

@@ -8,11 +8,14 @@ export class PaginatedHasManyFieldProvider implements EntityFieldsProvider<Pagin
 
 	constructor(private readonly schema: Model.Schema, private readonly visitor: PaginatedHasManyFieldProviderVisitor) {}
 
-	getFields(entity: Model.Entity, fields: string[]): FieldMap<PaginatedHasManyFieldProviderExtension> {
-		return fields.reduce(
-			(result, field) => ({ ...result, ...acceptFieldVisitor(this.schema, entity, field, this.visitor) }),
-			{},
-		)
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<PaginatedHasManyFieldProviderExtension> {
+		const fields: FieldMap<PaginatedHasManyFieldProviderExtension> = {}
+		for (const field of accessibleFields) {
+			for (const [name, fieldConfig] of acceptFieldVisitor(this.schema, entity, field, this.visitor)) {
+				fields[name] = fieldConfig
+			}
+		}
+		return fields
 	}
 }
 

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -1,13 +1,20 @@
 import { Model } from '@contember/schema'
-import { FieldMap } from '../EntityFieldsProvider'
-import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
+import { PaginatedHasManyFieldProvider, PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
 import { capitalizeFirstLetter } from '../../utils'
 import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory'
 import { aliasAwareResolver } from '../../schema'
+import { GraphQLFieldConfig } from 'graphql'
+
+type Result = [
+	string,
+	GraphQLFieldConfig<any, any> & {
+		extensions: PaginatedHasManyFieldProviderExtension
+	}
+]
 
 export class PaginatedHasManyFieldProviderVisitor implements
-	Model.ColumnVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>>,
-	Model.RelationByTypeVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>> {
+	Model.ColumnVisitor<Result[]>,
+	Model.RelationByTypeVisitor<Result[]> {
 
 	constructor(private readonly paginatedFieldFactory: PaginatedFieldConfigFactory) {}
 
@@ -23,31 +30,35 @@ export class PaginatedHasManyFieldProviderVisitor implements
 		return this.createField(targetEntity, relation)
 	}
 
-	private createField(entity: Model.Entity, relation: Model.Relation): FieldMap<PaginatedHasManyFieldProviderExtension> {
-		return {
-			[`paginate${capitalizeFirstLetter(relation.name)}`]: {
-				...this.paginatedFieldFactory.createFieldConfig(entity),
-				extensions: {
-					relationName: relation.name,
+	private createField(entity: Model.Entity, relation: Model.Relation): Result[] {
+		return [
+			[
+				`paginate${capitalizeFirstLetter(relation.name)}`,
+				{
+					...this.paginatedFieldFactory.createFieldConfig(entity),
+					extensions: {
+						relationName: relation.name,
+						extensionKey: PaginatedHasManyFieldProvider.extensionName,
+					},
+					resolve: aliasAwareResolver,
 				},
-				resolve: aliasAwareResolver,
-			},
-		}
+			],
+		]
 	}
 
 	visitColumn() {
-		return {}
+		return []
 	}
 
 	visitManyHasOne() {
-		return {}
+		return []
 	}
 
 	visitOneHasOneInverse() {
-		return {}
+		return []
 	}
 
 	visitOneHasOneOwning() {
-		return {}
+		return []
 	}
 }

package/src/introspection/IntrospectionSchemaDefinitionFactory.ts

@@ -5,6 +5,7 @@ import { JSONType } from '@contember/graphql-utils'
 import {
 	GraphQLBoolean,
 	GraphQLEnumType,
+	GraphQLFieldResolver,
 	GraphQLInt,
 	GraphQLInterfaceType,
 	GraphQLList,
@@ -176,6 +177,24 @@ const _Schema = new GraphQLObjectType({
 })
 
 
+const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
+	return {
+		query: new GraphQLObjectType({
+			name: 'Query',
+			fields: {
+				schema: {
+					type: _Schema,
+					resolve: resolver,
+				},
+			},
+		}),
+		types: [_Column, _Relation],
+	}
+}
+
+
+export default new GraphQLSchema(createSchemaConfig())
+
 export class IntrospectionSchemaDefinitionFactory {
 	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}
 
@@ -184,19 +203,8 @@ export class IntrospectionSchemaDefinitionFactory {
 	}
 
 	public createConfig(): GraphQLSchemaConfig {
-		return {
-			query: new GraphQLObjectType({
-				name: 'Query',
-				fields: {
-					schema: {
-						type: _Schema,
-						resolve: (): ContentSchema._Schema => {
-							return this.introspectionSchemaFactory.create()
-						},
-					},
-				},
-			}),
-			types: [_Column, _Relation],
-		}
+		return createSchemaConfig((): ContentSchema._Schema => {
+			return this.introspectionSchemaFactory.create()
+		})
 	}
 }

package/src/introspection/index.ts

@@ -1,4 +1,3 @@
-export { default as ContentSchema } from './content-schema.graphql'
 export * as ContentSchemaTypes from './content-schema.types'
-export * from './IntrospectionSchemaDefinitionFactory'
+export { IntrospectionSchemaDefinitionFactory, default as ContentSchema } from './IntrospectionSchemaDefinitionFactory'
 export * from './IntrospectionSchemaFactory'

package/src/mapper/ErrorUtils.ts

@@ -11,8 +11,9 @@ import {
 import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
-import { acceptFieldVisitor, SchemaDatabaseMetadata, tryGetColumnName } from '@contember/schema-utils'
+import { acceptFieldVisitor, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
+import { DatabaseMetadata } from '@contember/database'
 
 
 type UniqueConstraintResult = {
@@ -22,8 +23,8 @@ type UniqueConstraintResult = {
 
 const getEntityByTableName = (model: Model.Schema, tableName: string) => Object.values(model.entities).find(it => it.tableName === tableName)
 
-const findUniqueConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
-	const constraint = databaseMetadata.getUniqueConstraint(tableName, constraintName)
+const findUniqueConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+	const constraint = databaseMetadata.uniqueConstraints.filter({ tableName, constraintName }).first()
 	if (!constraint) {
 		return null
 	}
@@ -50,8 +51,8 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
-	const constraint = databaseMetadata.getForeignKeyConstraint(tableName, constraintName)
+const findForeignConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+	const constraint = databaseMetadata.foreignKeys.filter({ fromTable: tableName, constraintName }).first()
 	if (!constraint) {
 		return null
 	}
@@ -88,7 +89,7 @@ const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaData
 
 export const convertError = (
 	schema: Model.Schema,
-	databaseMetadata: SchemaDatabaseMetadata,
+	databaseMetadata: DatabaseMetadata,
 	e: any,
 ): MutationResult => {
 
@@ -140,7 +141,7 @@ export const convertError = (
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (schema: Model.Schema, databaseMetadata: DatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {

package/src/mapper/Mapper.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { acceptFieldVisitor, getColumnName, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
 import {
 	OrderByHelper,
 	PathFactory,
@@ -10,7 +10,7 @@ import {
 	SelectResultObject,
 	WhereBuilder,
 } from './select'
-import { Client, Connection, ConstraintHelper, SelectBuilder } from '@contember/database'
+import { Client, Connection, ConstraintHelper, DatabaseMetadata, SelectBuilder } from '@contember/database'
 import { PredicatesInjector } from '../acl'
 import { JunctionTableManager } from './JunctionTableManager'
 import { DeletedEntitiesStorage, DeleteExecutor } from './delete'
@@ -38,7 +38,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		public readonly identityId: string,
 		public readonly transactionId: string,
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -49,7 +49,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		private readonly inserter: Inserter,
 		private readonly pathFactory: PathFactory,
 	) {
-		this.constraintHelper = new ConstraintHelper(db)
+		this.constraintHelper = new ConstraintHelper(db, this.schemaDatabaseMetadata)
 		this.eventManager = new EventManager(this)
 	}
 

package/src/mapper/MapperFactory.ts

@@ -6,9 +6,9 @@ import { DeleteExecutor } from './delete'
 import { Updater } from './update'
 import { Inserter } from './insert'
 import { Model } from '@contember/schema'
-import { Client, Connection } from '@contember/database'
+import { Client, Connection, DatabaseMetadata } from '@contember/database'
 import { Mapper } from './Mapper'
-import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { Providers } from '@contember/schema-utils'
 
 export type MapperFactoryHook = (mapper: Mapper) => void
 
@@ -20,7 +20,7 @@ export class MapperFactory {
 		private readonly db: Client,
 		private readonly identityId: string,
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,

package/src/mapper/Result.ts

@@ -1,9 +1,8 @@
 import { Input, Model, Value } from '@contember/schema'
 import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
-import { SerializationFailureError } from '@contember/database'
+import { DatabaseMetadata, SerializationFailureError } from '@contember/database'
 import { logger } from '@contember/logger'
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -213,7 +212,7 @@ export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
 	schema: Model.Schema,
-	schemaDatabaseMetadata: SchemaDatabaseMetadata,
+	schemaDatabaseMetadata: DatabaseMetadata,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {

package/src/mapper/delete/DeleteExecutor.ts

@@ -252,7 +252,7 @@ export class DeleteExecutor {
 		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
 		values: Input.PrimaryValue[],
 	): Promise<void> {
-		if (mapper.constraintHelper.areFkConstraintsDeferred()) {
+		if (mapper.constraintHelper.areConstraintsDeferred('foreignKey')) {
 			return
 		}
 		const qb = this.createFetchByIdQueryBuilder(entity, relation, values)

package/src/mapper/insert/Inserter.ts

@@ -11,16 +11,17 @@ import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
 import { Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
 import { InsertBuilder } from './InsertBuilder'
 import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
+import { DatabaseMetadata } from '@contember/database'
 
 export class Inserter {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
 	) {}

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -1,19 +1,18 @@
-import { Acl, Input, Model } from '@contember/schema'
+import { Acl, Input, Model, Settings } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
-import { WhereBuilder } from '../WhereBuilder'
+import { Literal, wrapIdentifier } from '@contember/database'
 
 export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.ColumnVisitor<void> {
 	constructor(
-		private readonly schema: Model.Schema,
 		private readonly relationFetcher: RelationFetcher,
 		private readonly predicateFactory: PredicateFactory,
-		private readonly whereBuilder: WhereBuilder,
 		private readonly mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
 		private readonly relationPath: Model.AnyRelationContext[],
+		private readonly settings: Settings.ContentSettings,
 	) {}
 
 	visitColumn({ entity, column }: Model.ColumnContext): void {
@@ -21,8 +20,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		const tableAlias = columnPath.back().alias
 		const columnAlias = columnPath.alias
 
+		let selectFrom = wrapIdentifier(tableAlias) + '.' + wrapIdentifier(column.columnName)
+		if (column.type === Model.ColumnType.Date && this.settings.shortDateResponse) {
+			selectFrom += '::text'
+		}
+
 		this.executionContext.addColumn({
-			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			query: qb => qb.select(new Literal(selectFrom), columnAlias),
 			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}

package/src/mapper/select/handlers/FieldsVisitorFactory.ts

@@ -1,28 +1,25 @@
 import { FieldsVisitor } from './FieldsVisitor'
 import { RelationFetcher } from '../RelationFetcher'
-import { Model } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
-import { WhereBuilder } from '../WhereBuilder'
+import { Settings } from '@contember/schema'
 
 export class FieldsVisitorFactory {
 	constructor(
-		private readonly schema: Model.Schema,
 		private readonly relationFetcher: RelationFetcher,
 		private readonly predicateFactory: PredicateFactory,
-		private readonly whereBuilder: WhereBuilder,
+		private readonly settings: Settings.ContentSettings,
 	) {}
 
 	create(mapper: Mapper, context: SelectExecutionHandlerContext): FieldsVisitor {
 		return new FieldsVisitor(
-			this.schema,
 			this.relationFetcher,
 			this.predicateFactory,
-			this.whereBuilder,
 			mapper,
 			context,
 			context.relationPath,
+			this.settings,
 		)
 	}
 }

package/src/mapper/update/Updater.ts

@@ -4,7 +4,7 @@ import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
-import { acceptEveryFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor } from '@contember/schema-utils'
 import {
 	collectResults,
 	MutationNoResultError,
@@ -17,11 +17,12 @@ import {
 } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
+import { DatabaseMetadata } from '@contember/database'
 
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}