@contember/engine-content-api 2.0.0 → 2.1.0-alpha.1

package/package.json

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

package/src/ExecutionContainer.ts

@@ -169,7 +169,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,

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

@@ -27,6 +27,9 @@ 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[]'
+		}
 
 		this.executionContext.addColumn({
 			query: qb => qb.select(new Literal(selectFrom), columnAlias),

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/OrderByTypeProvider.ts

@@ -57,7 +57,12 @@ export class OrderByTypeProvider {
 			}
 
 			const field = acceptFieldVisitor(this.schema, name, fieldName, {
-				visitColumn: () => ({ type: this.orderDirectionEnum }),
+				visitColumn: ({ column }) => {
+					if (column.list) {
+						return undefined
+					}
+					return ({ type: this.orderDirectionEnum })
+				},
 				visitHasOne: ({ relation }) => ({ type: this.getEntityOrderByType(relation.target) }),
 				visitHasMany: () => undefined,
 			} as Model.FieldVisitor<GraphQLInputFieldConfig | undefined>)

package/src/schema/WhereTypeProvider.ts

@@ -83,7 +83,7 @@ export class WhereTypeProvider {
 						}
 						return { type: uniqueWhere }
 					},
-					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column) }),
+					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column)[0] }),
 				})
 			}
 		}

package/src/schema/entities/FieldTypeVisitor.ts

@@ -14,16 +14,16 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 	}
 
 	public visitColumn({ column, entity }: Model.ColumnContext): GraphQLOutputType {
-		const basicType = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		const fieldPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, column.name)
 		const idPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, entity.primary)
 		if (!fieldPredicate || !idPredicate) {
 			throw new ImplementationException()
 		}
 		if (!column.nullable && (fieldPredicate === true || fieldPredicate === idPredicate)) {
-			return new GraphQLNonNull(basicType)
+			return new GraphQLNonNull(type)
 		}
-		return basicType
+		return type
 	}
 
 	public visitHasMany({ relation }: Model.AnyHasManyRelationContext): GraphQLOutputType {

package/src/schema/mutations/CreateEntityInputFieldVisitor.ts

@@ -22,7 +22,7 @@ export class CreateEntityInputFieldVisitor implements
 		if (this.authorizator.getFieldPermissions(Acl.Operation.create, entity.name, column.name) === 'no') {
 			return undefined
 		}
-		const type = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		return { type }
 	}
 

package/src/schema/mutations/UpdateEntityInputFieldVisitor.ts

@@ -21,7 +21,7 @@ export class UpdateEntityInputFieldVisitor implements
 		if (this.authorizator.getFieldPermissions(Acl.Operation.update, entity.name, column.name) === 'no') {
 			return undefined
 		}
-		const type = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		return { type }
 	}
 

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

@@ -61,7 +61,26 @@ const testSchema = async (test: Test) => {
 	}
 }
 describe('GraphQL schema builder', () => {
-
+	it('column types', async () => {
+		await testSchema({
+			schema: () => createSchema({
+				Columns: class Columns {
+					string = c.stringColumn()
+					int = c.intColumn()
+					float = c.doubleColumn()
+					boolean = c.boolColumn()
+					date = c.dateColumn()
+					dateTime = c.dateTimeColumn()
+					json = c.jsonColumn()
+					uuid = c.uuidColumn()
+					time = c.timeColumn()
+					enum = c.enumColumn(c.createEnum('a', 'b', 'c'))
+				},
+			}).model,
+			permissions: schema => new AllowAllPermissionFactory().create(schema),
+			graphQlSchemaFile: 'schema-column-types.gql',
+		})
+	})
 
 	it('basic schema', async () => {
 		await testSchema({
@@ -402,6 +421,23 @@ describe('GraphQL schema builder', () => {
 			graphQlSchemaFile: 'schema-no-root-ops.gql',
 		})
 	})
+
+
+	it('array', async () => {
+		const schema = createSchema({
+			Foo: class Foo {
+				stringArrayValue = c.stringColumn().list()
+				enumArrayValue = c.enumColumn(c.createEnum('a', 'b', 'c')).list()
+				intArrayValue = c.intColumn().list()
+			},
+		})
+
+		await testSchema({
+			schema: () => schema.model,
+			permissions: schema => new AllowAllPermissionFactory().create(schema),
+			graphQlSchemaFile: 'schema-array.gql',
+		})
+	})
 })
 
 namespace ViewEntity {

package/tests/cases/integration/graphQlSchema/schema-aliased-type.gql

@@ -70,6 +70,12 @@ input AuthorNameCondition {
   lte: AuthorName
   gt: AuthorName
   gte: AuthorName
+  contains: String
+  startsWith: String
+  endsWith: String
+  containsCI: String
+  startsWithCI: String
+  endsWithCI: String
 }
 
 input AuthorOrderBy {