@contember/engine-content-api 2.0.2 → 2.1.0-alpha.10

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

@@ -1 +1 @@
-{"version":3,"file":"isIt.d.ts","sourceRoot":"","sources":["../../../src/utils/isIt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,iBAAiB,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAG,GAAG,IAAI,CAKhH,CAAA"}
+{"version":3,"file":"isIt.d.ts","sourceRoot":"","sources":["../../../src/utils/isIt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAG,GAAG,IAAI,CAKhH,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"paginationUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/paginationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,qBAAa,gBAAgB;aAEX,aAAa,EAAE,UAAU,GAAG,SAAS;aACrC,SAAS,EAAE,UAAU,GAAG,SAAS;gBADjC,aAAa,EAAE,UAAU,GAAG,SAAS,EACrC,SAAS,EAAE,UAAU,GAAG,SAAS;IAGlD,IAAI,kBAAkB,YAErB;IAED,IAAI,aAAa,YAEhB;IAEM,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG;CAc9E;AACD,eAAO,MAAM,sBAAsB,aAAc,UAAU,CAAC,KAAK,CAAC,oBAAoB,CAAC,qBAmBtF,CAAA"}
+{"version":3,"file":"paginationUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/paginationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,qBAAa,gBAAgB;aAEX,aAAa,EAAE,UAAU,GAAG,SAAS;aACrC,SAAS,EAAE,UAAU,GAAG,SAAS;gBADjC,aAAa,EAAE,UAAU,GAAG,SAAS,EACrC,SAAS,EAAE,UAAU,GAAG,SAAS;IAGlD,IAAI,kBAAkB,YAErB;IAED,IAAI,aAAa,YAEhB;IAEM,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG;CAc9E;AACD,eAAO,MAAM,sBAAsB,GAAI,UAAU,UAAU,CAAC,KAAK,CAAC,oBAAoB,CAAC,qBAmBtF,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"promises.d.ts","sourceRoot":"","sources":["../../../src/utils/promises.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,YAAa,oBAAoB,CAAC,GAAG,CAAC,EAAE,KAAG,GAAG,EAEvE,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,WAAW,oBAAoB,CAAC,CAAC,CAAC,EAAE,KAAG,CAAC,EAE3E,CAAA"}
+{"version":3,"file":"promises.d.ts","sourceRoot":"","sources":["../../../src/utils/promises.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,SAAS,oBAAoB,CAAC,GAAG,CAAC,EAAE,KAAG,GAAG,EAEvE,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,SAAS,oBAAoB,CAAC,CAAC,CAAC,EAAE,KAAG,CAAC,EAE3E,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"singletonFactory.d.ts","sourceRoot":"","sources":["../../../src/utils/singletonFactory.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,EAAE,WAAW,IAAI,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,CAAC,YAGjF,EAAE,SAAS,IAAI,KAAG,CAkBhC,CAAA"}
+{"version":3,"file":"singletonFactory.d.ts","sourceRoot":"","sources":["../../../src/utils/singletonFactory.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,CAAC,MAGvF,MAAM,EAAE,EAAE,OAAO,IAAI,KAAG,CAkBhC,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../src/utils/strings.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,UAAW,MAAM,WAE3C,CAAA;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../src/utils/strings.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,GAAI,OAAO,MAAM,WAE3C,CAAA;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,OAAO,EAAE,WAAW,CAAC,MAAS,CAAA"}
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,GAAG,MAAM,CAAC,MAAS,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"uniqueWhereFields.d.ts","sourceRoot":"","sources":["../../../src/utils/uniqueWhereFields.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,KAAK,YAAY,GAAG,SAAS,MAAM,EAAE,CAAA;AACrC,eAAO,MAAM,uBAAuB,WAAY,KAAK,CAAC,MAAM,UAAU,KAAK,CAAC,MAAM,KAAG,SAAS,CAAC,YAAY,CAAC,EAc3G,CAAA"}
+{"version":3,"file":"uniqueWhereFields.d.ts","sourceRoot":"","sources":["../../../src/utils/uniqueWhereFields.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,KAAK,YAAY,GAAG,SAAS,MAAM,EAAE,CAAA;AACrC,eAAO,MAAM,uBAAuB,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,KAAG,SAAS,CAAC,YAAY,CAAC,EAc3G,CAAA"}

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

@@ -0,0 +1,2 @@
+export declare const viewComputedId: (inputs: (string)[]) => string;
+//# sourceMappingURL=viewComputedId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewComputedId.d.ts","sourceRoot":"","sources":["../../../src/utils/viewComputedId.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAG,MAWnD,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "2.0.2",
+  "version": "2.1.0-alpha.10",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -26,19 +26,19 @@
     "generate": "gql-gen --config graphql.codegen.yml"
   },
   "dependencies": {
-    "@contember/database": "2.0.2",
-    "@contember/dic": "2.0.2",
-    "@contember/graphql-utils": "2.0.2",
-    "@contember/logger": "2.0.2",
-    "@contember/schema": "2.0.2",
-    "@contember/schema-definition": "2.0.2",
-    "@contember/schema-utils": "2.0.2",
+    "@contember/database": "2.1.0-alpha.10",
+    "@contember/dic": "2.1.0-alpha.10",
+    "@contember/graphql-utils": "2.1.0-alpha.10",
+    "@contember/logger": "2.1.0-alpha.10",
+    "@contember/schema": "2.1.0-alpha.10",
+    "@contember/schema-definition": "2.1.0-alpha.10",
+    "@contember/schema-utils": "2.1.0-alpha.10",
     "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "2.0.2",
-    "@contember/schema-definition": "2.0.2",
-    "@types/node": "^20.16.11",
+    "@contember/database-tester": "2.1.0-alpha.10",
+    "@contember/schema-definition": "2.1.0-alpha.10",
+    "@types/node": "^20.17.22",
     "graphql": "^16.9.0",
     "pg": "^8.12.0"
   },

package/src/ExecutionContainer.ts

@@ -28,7 +28,7 @@ import {
 import { Builder } from '@contember/dic'
 import { Acl, Model, Schema } from '@contember/schema'
 import { Client, DatabaseMetadata, SelectBuilder as DbSelectBuilder } from '@contember/database'
-import { Providers } from '@contember/schema-utils'
+import { ParsedMembership, Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
@@ -41,6 +41,7 @@ import {
 	QueryAstFactory,
 	ValidationDataSelector,
 } from './input-validation'
+import { RefreshViewResolver } from './resolvers/RefreshViewResolver'
 
 export type ExecutionContainerArgs = {
 	schema: Schema
@@ -59,6 +60,7 @@ export interface ExecutionContainer {
 	readResolver: ReadResolver
 	mutationResolver: MutationResolver
 	validationResolver: ValidationResolver
+	refreshViewResolver: RefreshViewResolver
 }
 
 export type ExecutionContainerBuilder = ReturnType<ExecutionContainerFactory['createBuilderInternal']>
@@ -122,8 +124,8 @@ export class ExecutionContainerFactory {
 				new OrderByBuilder(schema.model, joinBuilder))
 			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
 				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
-			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, schema }) =>
-				new FieldsVisitorFactory(relationFetcher, predicateFactory, schema.settings.content ?? {}))
+			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, schema, providers }) =>
+				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, schema.settings.content ?? {}, providers))
 			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
 				new MetaHandler(whereBuilder, predicateFactory))
 			.addService('uniqueWhereExpander', ({ schema }) =>
@@ -169,7 +171,7 @@ export class ExecutionContainerFactory {
 			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema, schemaDatabaseMetadata }) =>
 				new Updater(schema.model, schemaDatabaseMetadata, predicateFactory, updateBuilderFactory))
 			.addService('inserter', ({  insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
-				new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers))
+				new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers, { uuidVersion: schema.settings.content?.uuidVersion }))
 			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema, schemaDatabaseMetadata }) => {
 				return new MapperFactory(
 					db,
@@ -209,10 +211,12 @@ export class ExecutionContainerFactory {
 				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata))
 			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
 				new ValidationResolver(mapperFactory, inputPreValidator))
+			.addService('refreshViewResolver', ({ schema, mapperFactory }) =>
+				new RefreshViewResolver(schema, mapperFactory))
 	}
 
 	public create(args: ExecutionContainerArgs): ExecutionContainer {
-		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver')
+		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver', 'refreshViewResolver')
 	}
 }
 

package/src/acl/Authorizator.ts

@@ -7,6 +7,7 @@ export class Authorizator {
 	constructor(
 		private readonly permissions: Acl.Permissions,
 		private readonly defaultCustomPrimary: boolean,
+		private readonly allowRefreshMaterializedView: boolean,
 	) {
 	}
 
@@ -56,4 +57,8 @@ export class Authorizator {
 	isRootOperationDisallowed(entity: string, operation: Acl.Operation): boolean {
 		return this.permissions?.[entity]?.operations?.noRoot?.includes(operation) ?? false
 	}
+
+	isRefreshMaterializedViewAllowed(entity: string): boolean {
+		return this.permissions?.[entity]?.operations?.refreshMaterializedView ?? this.allowRefreshMaterializedView
+	}
 }

package/src/input-validation/ColumnValueResolver.ts

@@ -9,7 +9,7 @@ export class ColumnValueResolver {
 			return '00000000-0000-0000-0000-000000000000'
 		}
 		try {
-			return resolveColumnValue(context, this.providers)
+			return resolveColumnValue(context, this.providers, {})
 		} catch (e) {
 			if (e instanceof NoDataError) {
 				return undefined

package/src/mapper/insert/Inserter.ts

@@ -16,6 +16,7 @@ export class Inserter {
 		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
+		private readonly options: { uuidVersion?: 4 | 7 },
 	) {}
 
 	public async insert(
@@ -30,7 +31,7 @@ export class Inserter {
 		insertBuilder.addPredicates(Object.keys(data))
 
 		const visitor = new CreateInputVisitor<SqlCreateInputProcessorResult>(
-			new SqlCreateInputProcessor(insertBuilder, mapper, this.providers),
+			new SqlCreateInputProcessor(insertBuilder, mapper, this.providers, this.options),
 			this.schema,
 			data,
 		)

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -25,6 +25,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateIn
 		private readonly insertBuilder: InsertBuilder,
 		private readonly mapper: Mapper,
 		private readonly providers: Providers,
+		private readonly options: { uuidVersion?: 4 | 7 } = {},
 	) {
 		this.oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.mapper)
 		this.oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.mapper, this.insertBuilder)
@@ -36,7 +37,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateIn
 	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<SqlCreateInputProcessorResult> {
 		this.insertBuilder.addFieldValue(
 			context.column.name,
-			resolveColumnValue(context, this.providers),
+			resolveColumnValue(context, this.providers, this.options),
 		)
 		return []
 	}

package/src/mapper/select/ConditionBuilder.ts

@@ -1,5 +1,5 @@
-import { Input } from '@contember/schema'
-import { QueryBuilder, ConditionBuilder as SqlConditionBuilder, Operator } from '@contember/database'
+import { Input, Model } from '@contember/schema'
+import { QueryBuilder, ConditionBuilder as SqlConditionBuilder, Operator, Literal, formatColumnIdentifier, Compiler } from '@contember/database'
 import { UserError } from '../../exception'
 
 export class ConditionBuilder {
@@ -7,7 +7,7 @@ export class ConditionBuilder {
 		builder: SqlConditionBuilder,
 		tableName: string,
 		columnName: string,
-		columnType: string,
+		columnType: Pick<Model.AnyColumn, 'type' | 'list' | 'columnType'>,
 		condition: Input.Condition<any> | null,
 	): SqlConditionBuilder {
 		if (condition === null) {
@@ -37,21 +37,35 @@ export class ConditionBuilder {
 			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
 			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
 			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, columnType, expression)),
+
+			isNull: (builder, value) => value ? builder.isNull(columnIdentifier) : builder.not(clause => clause.isNull(columnIdentifier)),
+
 			eq: (builder, value) => builder.compare(columnIdentifier, Operator.eq, value),
 			notEq: (builder, value) => builder.compare(columnIdentifier, Operator.notEq, value),
-			isNull: (builder, value) => value ? builder.isNull(columnIdentifier) : builder.not(clause => clause.isNull(columnIdentifier)),
-			in: (builder, values) => builder.in(columnIdentifier, values, columnType),
+			in: (builder, values) => builder.in(columnIdentifier, values, columnType.columnType),
 			notIn: (builder, values) => builder.not(builder2 => builder2.in(columnIdentifier, values)),
 			lt: (builder, value) => builder.compare(columnIdentifier, Operator.lt, value),
 			lte: (builder, value) => builder.compare(columnIdentifier, Operator.lte, value),
 			gt: (builder, value) => builder.compare(columnIdentifier, Operator.gt, value),
 			gte: (builder, value) => builder.compare(columnIdentifier, Operator.gte, value),
+
+			includes: (builder, value) => {
+				const cast = columnType.type === Model.ColumnType.Enum
+					? `${Compiler.SCHEMA_PLACEHOLDER}."${columnType.columnType}"`
+					: columnType.columnType
+
+				return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ARRAY[?]::${cast}[]`, value)
+			},
+			maxLength: (builder, value) => builder.raw(`array_length(${formatColumnIdentifier(columnIdentifier)}, 1) <= ?`, value),
+			minLength: (builder, value) => builder.raw(`array_length(${formatColumnIdentifier(columnIdentifier)}, 1) >= ?`, value),
+
 			contains: (builder, value) => builder.compare(columnIdentifier, Operator.contains, value),
 			startsWith: (builder, value) => builder.compare(columnIdentifier, Operator.startsWith, value),
 			endsWith: (builder, value) => builder.compare(columnIdentifier, Operator.endsWith, value),
 			containsCI: (builder, value) => builder.compare(columnIdentifier, Operator.containsCI, value),
 			startsWithCI: (builder, value) => builder.compare(columnIdentifier, Operator.startsWithCI, value),
 			endsWithCI: (builder, value) => builder.compare(columnIdentifier, Operator.endsWithCI, value),
+
 			never: builder => builder.raw('false'),
 			always: builder => builder.raw('true'),
 

package/src/mapper/select/WhereBuilder.ts

@@ -160,7 +160,7 @@ export class WhereBuilder {
 							conditionBuilder,
 							tableName,
 							relation.joiningColumn.columnName,
-							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType,
+							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn),
 							primaryCondition,
 						)
 					}
@@ -182,7 +182,7 @@ export class WhereBuilder {
 
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
 				visitColumn: ({ entity, column }) => {
-					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, fieldWhere as Input.Condition<Input.ColumnValue>)
+					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column, fieldWhere as Input.Condition<Input.ColumnValue>)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
@@ -275,7 +275,7 @@ export class WhereBuilder {
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
 
-			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
+			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn)
 
 			return qb.where(condition =>
 				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),

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

@@ -4,20 +4,27 @@ import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
 import { Literal, wrapIdentifier } from '@contember/database'
+import { ColumnValueGetter } from '../SelectHydrator'
+import { Providers } from '@contember/schema-utils'
+import { getColumnName } from '@contember/schema-utils'
+import { viewComputedId } from '../../../utils/viewComputedId'
 
 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 mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
 		private readonly relationPath: Model.AnyRelationContext[],
 		private readonly settings: Settings.ContentSettings,
+		private readonly providers: Providers,
 	) {}
 
 	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
-		const tableAlias = columnPath.back().alias
+		const tablePath = columnPath.back()
+		const tableAlias = tablePath.alias
 		const columnAlias = columnPath.alias
 
 		let selectFrom = wrapIdentifier(tableAlias) + '.' + wrapIdentifier(column.columnName)
@@ -27,10 +34,38 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		if (column.type === Model.ColumnType.DateTime && this.settings.fullDateTimeResponse) {
 			selectFrom += '::text'
 		}
+		if (column.type === Model.ColumnType.Enum && column.list) {
+			selectFrom += '::text[]'
+		}
+
+		let columnValueGetter: ColumnValueGetter | undefined = undefined
+		if (entity.view && column.name === entity.primary && column.type === Model.ColumnType.Uuid) {
+			if (entity.view.idSource) {
+				const aliases: string[] = []
+				for (const source of entity.view.idSource) {
+					const columnName = getColumnName(this.schema, entity, source)
+					const idSrcPath = columnPath.for(source + '__id_src')
+					aliases.push(idSrcPath.alias)
+					this.executionContext.addColumn({
+						query: qb => qb.select([tableAlias, columnName], idSrcPath.alias),
+					})
+				}
+
+				columnValueGetter = row => {
+					return viewComputedId(aliases.map(it => row[it]?.toString() || ''))
+				}
+			} else {
+				columnValueGetter = row => {
+					return row[columnAlias] ?? (this.providers.uuid({ version: this.settings.uuidVersion }))
+				}
+
+			}
+		}
 
 		this.executionContext.addColumn({
 			query: qb => qb.select(new Literal(selectFrom), columnAlias),
 			predicate: this.getRequiredPredicate(entity, column),
+			valueGetter: columnValueGetter,
 		})
 	}
 

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

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

package/src/resolvers/RefreshViewResolver.ts

@@ -0,0 +1,23 @@
+import { Schema } from '@contember/schema'
+import { MapperFactory } from '../mapper'
+import { wrapIdentifier } from '@contember/database'
+
+export class RefreshViewResolver {
+	constructor(
+		private readonly schema: Schema,
+		private readonly mapperFactory: MapperFactory,
+	) {
+	}
+
+	public async resolve(entity: string, options?: { concurrently?: boolean }): Promise<{ ok: boolean }> {
+		const mapper = this.mapperFactory.create()
+		const entityModel = this.schema.model.entities[entity]
+		if (!entityModel) {
+			throw new Error(`Entity ${entity} not found`)
+		}
+		const concurrently = options?.concurrently ? ' CONCURRENTLY' : ''
+		await mapper.db.query(`REFRESH MATERIALIZED VIEW${concurrently} ${wrapIdentifier(mapper.db.schema)}.${wrapIdentifier(entityModel.tableName)}`)
+
+		return { ok: true }
+	}
+}

package/src/schema/ColumnTypeResolver.ts

@@ -1,4 +1,4 @@
-import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLInt, GraphQLScalarType, GraphQLString } from 'graphql'
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLScalarType, GraphQLString } from 'graphql'
 import { Model } from '@contember/schema'
 import { EnumsProvider } from './EnumsProvider'
 import { CustomTypesProvider } from './CustomTypesProvider'
@@ -7,6 +7,8 @@ import { singletonFactory } from '../utils'
 
 type ScalarType = Exclude<Model.ColumnType, Model.ColumnType.Enum>
 
+export type ColumnGraphQLType = GraphQLScalarType | GraphQLEnumType | GraphQLList<GraphQLNonNull<GraphQLScalarType | GraphQLEnumType>>
+
 export class ColumnTypeResolver {
 	private schema: Model.Schema
 	private enumsProvider: EnumsProvider
@@ -36,7 +38,15 @@ export class ColumnTypeResolver {
 		}
 	}
 
-	public getType(column: Model.AnyColumn): GraphQLScalarType | GraphQLEnumType {
+	public getType(column: Model.AnyColumn): [type: ColumnGraphQLType, baseType: GraphQLScalarType | GraphQLEnumType] {
+		const baseType = this.getBaseType(column)
+		return [
+			column.list ? new GraphQLList(new GraphQLNonNull(baseType)) : baseType,
+			baseType,
+		]
+	}
+
+	private getBaseType(column: Model.AnyColumn): GraphQLScalarType | GraphQLEnumType {
 		if (column.typeAlias) {
 			if (column.type === Model.ColumnType.Enum) {
 				throw new Error('GraphQL type alias cannot be specified for enum type')
@@ -62,7 +72,7 @@ export class ColumnTypeResolver {
 		}
 	}
 
-	public getScalarType(type: ScalarType): GraphQLScalarType {
+	private getScalarType(type: ScalarType): GraphQLScalarType {
 		switch (type) {
 			case Model.ColumnType.Int:
 				return GraphQLInt
@@ -76,6 +86,8 @@ export class ColumnTypeResolver {
 				return GraphQLBoolean
 			case Model.ColumnType.DateTime:
 				return this.customTypeProvider.dateTimeType
+			case Model.ColumnType.Time:
+				return this.customTypeProvider.timeType
 			case Model.ColumnType.Date:
 				return this.customTypeProvider.dateType
 			case Model.ColumnType.Json:

package/src/schema/ConditionTypeProvider.ts

@@ -4,6 +4,7 @@ import {
 	GraphQLEnumType,
 	GraphQLInputFieldConfigMap,
 	GraphQLInputObjectType,
+	GraphQLInt,
 	GraphQLList,
 	GraphQLNonNull,
 	GraphQLScalarType,
@@ -12,24 +13,30 @@ import {
 import { singletonFactory } from '../utils'
 import { ColumnTypeResolver } from './ColumnTypeResolver'
 import { GqlTypeName } from './utils'
+import { ImplementationException } from '../exception'
 
 export class ConditionTypeProvider {
-	private conditions = singletonFactory<GraphQLInputObjectType, string, GraphQLScalarType | GraphQLEnumType>(
-		(name, type) => this.createCondition(type),
+	private conditions = singletonFactory<GraphQLInputObjectType, string, [GraphQLScalarType | GraphQLEnumType, Model.AnyColumn]>(
+		(name, [type, column]) => this.createCondition(name, column, type),
 	)
 
 	constructor(private readonly columnTypeResolver: ColumnTypeResolver) {}
 
 	public getCondition(column: Model.AnyColumn): GraphQLInputObjectType {
-		const basicType = this.columnTypeResolver.getType(column)
-		return this.conditions(basicType.name, basicType)
+		const [graphqlType, baseType] = this.columnTypeResolver.getType(column)
+		const name = this.createName(column, baseType.name)
+		return this.conditions(name, [baseType, column])
 	}
 
-	private createCondition(type: GraphQLScalarType | GraphQLEnumType): GraphQLInputObjectType {
-		const suffix =
-			typeof type === 'object' && type.constructor && type.constructor.name === 'GraphQLEnumType' ? 'Enum' : ''
+	private createName(column: Model.AnyColumn, typeName: string): string {
+		const suffix = column.type === Model.ColumnType.Enum ? 'Enum' : ''
+		const arraySuffix = column.list ? 'List' : ''
+		return GqlTypeName`${typeName}${suffix}${arraySuffix}Condition`
+	}
+
+	private createCondition(name: string, column: Model.AnyColumn, type: GraphQLScalarType | GraphQLEnumType): GraphQLInputObjectType {
 		const condition: GraphQLInputObjectType = new GraphQLInputObjectType({
-			name: GqlTypeName`${type.name}${suffix}Condition`,
+			name: name,
 			fields: (): GraphQLInputFieldConfigMap => {
 				const conditions: GraphQLInputFieldConfigMap = {
 					and: { type: new GraphQLList(new GraphQLNonNull(condition)) },
@@ -39,25 +46,33 @@ export class ConditionTypeProvider {
 					null: { type: GraphQLBoolean },
 					isNull: { type: GraphQLBoolean },
 				}
-				if (type.name !== 'Json') {
-					conditions.eq = { type }
-					conditions.notEq = { type }
-					conditions.in = { type: new GraphQLList(new GraphQLNonNull(type)) }
-					conditions.notIn = { type: new GraphQLList(new GraphQLNonNull(type)) }
-					conditions.lt = { type: type }
-					conditions.lte = { type: type }
-					conditions.gt = { type: type }
-					conditions.gte = { type: type }
-				}
-				if (type.name === 'String') {
-					conditions.contains = { type: GraphQLString }
-					conditions.startsWith = { type: GraphQLString }
-					conditions.endsWith = { type: GraphQLString }
+				if (column.list) {
+					conditions.minLength = { type: GraphQLInt }
+					conditions.maxLength = { type: GraphQLInt }
+					conditions.includes = { type: type }
+				} else {
+					if (column.type !== Model.ColumnType.Json) {
+						conditions.eq = { type }
+						conditions.notEq = { type }
+						conditions.in = { type: new GraphQLList(new GraphQLNonNull(type)) }
+						conditions.notIn = { type: new GraphQLList(new GraphQLNonNull(type)) }
+						conditions.lt = { type: type }
+						conditions.lte = { type: type }
+						conditions.gt = { type: type }
+						conditions.gte = { type: type }
+					}
+					if (column.type === Model.ColumnType.String) {
+						conditions.contains = { type: GraphQLString }
+						conditions.startsWith = { type: GraphQLString }
+						conditions.endsWith = { type: GraphQLString }
 
-					conditions.containsCI = { type: GraphQLString }
-					conditions.startsWithCI = { type: GraphQLString }
-					conditions.endsWithCI = { type: GraphQLString }
+						conditions.containsCI = { type: GraphQLString }
+						conditions.startsWithCI = { type: GraphQLString }
+						conditions.endsWithCI = { type: GraphQLString }
+					}
 				}
+
+
 				return conditions
 			},
 		})

package/src/schema/CustomTypesProvider.ts

@@ -1,11 +1,31 @@
 import { GraphQLScalarType, Kind } from 'graphql'
 import { JSONType, UuidType } from '@contember/graphql-utils'
 
+const TIME_REGEX = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d+))?)?$/
+
+function validateTime(value: unknown): string {
+	if (typeof value !== 'string') {
+		throw new TypeError(`Time value must be a string, got: ${typeof value}`)
+	}
+	const match = TIME_REGEX.exec(value)
+	if (!match) {
+		throw new TypeError(`Value is not a valid time: ${value}`)
+	}
+
+	const hours = match[1]
+	const minutes = match[2]
+	const seconds = match[3] || '00'
+	const fraction = match[4] ? `.${match[4]}` : ''
+
+	return `${hours}:${minutes}:${seconds}${fraction}`
+}
+
 
 export class CustomTypesProvider {
 	public readonly uuidType: GraphQLScalarType = UuidType
 
 	//todo: implement serialize, parseValue and parseLiteral properly
+
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'Date',
 		serialize: str => String(str),
@@ -14,6 +34,23 @@ export class CustomTypesProvider {
 			return ast.kind === Kind.STRING ? ast.value : undefined
 		},
 	})
+
+	public readonly timeType: GraphQLScalarType = new GraphQLScalarType({
+		name: 'Time',
+		serialize(value) {
+			return validateTime(value)
+		},
+		parseValue(value) {
+			return validateTime(value)
+		},
+		parseLiteral(ast) {
+			if (ast.kind !== Kind.STRING) {
+				throw new TypeError(`Time scalar can only parse string values, got: ${ast.kind}`)
+			}
+			return validateTime(ast.value)
+		},
+	})
+
 	public readonly dateTimeType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'DateTime',
 		serialize: str => String(str),

package/src/schema/GraphQlSchemaBuilder.ts

@@ -15,6 +15,7 @@ import { QueryProvider } from './QueryProvider'
 import { ValidationQueriesProvider } from './ValidationQueriesProvider'
 import { Context } from '../types'
 import { ResultSchemaTypeProvider } from './ResultSchemaTypeProvider'
+import { RefreshViewMutationProvider } from './RefreshViewMutationProvider'
 
 type BuildArgs = {
 	queries?: Map<string, GraphQLFieldConfig<any, Context, any>>
@@ -29,6 +30,7 @@ export class GraphQlSchemaBuilder {
 		private readonly validationQueriesProvider: ValidationQueriesProvider,
 		private readonly mutationProvider: MutationProvider,
 		private readonly resultSchemaTypeProvider: ResultSchemaTypeProvider,
+		private readonly refreshViewMutationProvider: RefreshViewMutationProvider,
 	) {}
 
 	public build(args: BuildArgs = {}): GraphQLSchema {
@@ -117,6 +119,12 @@ export class GraphQlSchemaBuilder {
 				resolve: (parent, args, context: Context, info) => context.executionContainer.readResolver.resolveQuery(info),
 			})
 		}
+
+		const refreshViewMutation = this.refreshViewMutationProvider.getMutation()
+		if (refreshViewMutation) {
+			mutations.set('refreshMaterializedView', refreshViewMutation)
+		}
+
 		const infoType = new GraphQLObjectType({
 			name: 'Info',
 			fields: () => ({