@contember/engine-content-api 1.2.0-alpha.2 → 1.2.0-alpha.5

package/graphql.codegen.yml

@@ -10,9 +10,6 @@ generates:
     plugins:
       - "typescript"
       - "typescript-operations"
-      - "typescript-resolvers"
-require:
-  - "ts-node/register"
 hooks:
   afterAllFileWrite:
     - eslint --fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.2",
+  "version": "1.2.0-alpha.5",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,25 +10,25 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.2",
-    "@contember/dic": "^1.2.0-alpha.2",
-    "@contember/engine-common": "^1.2.0-alpha.2",
-    "@contember/graphql-utils": "^1.2.0-alpha.2",
-    "@contember/schema": "^1.2.0-alpha.2",
-    "@contember/schema-utils": "^1.2.0-alpha.2",
+    "@contember/database": "^1.2.0-alpha.5",
+    "@contember/dic": "^1.2.0-alpha.5",
+    "@contember/engine-common": "^1.2.0-alpha.5",
+    "@contember/graphql-utils": "^1.2.0-alpha.5",
+    "@contember/schema": "^1.2.0-alpha.5",
+    "@contember/schema-utils": "^1.2.0-alpha.5",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.2",
-    "@contember/engine-api-tester": "^1.2.0-alpha.2",
-    "@contember/schema-definition": "^1.2.0-alpha.2",
-    "@graphql-codegen/cli": "^1.15.2",
-    "@graphql-codegen/typescript": "^1.15.2",
-    "@graphql-codegen/typescript-operations": "^1.15.2",
-    "@graphql-codegen/typescript-resolvers": "^1.15.2",
-    "@types/node": "^17.0.5",
-    "graphql": "^15.4.0",
+    "@contember/database-tester": "^1.2.0-alpha.5",
+    "@contember/engine-api-tester": "^1.2.0-alpha.5",
+    "@contember/schema-definition": "^1.2.0-alpha.5",
+    "@graphql-codegen/cli": "^2.6.2",
+    "@graphql-codegen/typescript": "^2.5.1",
+    "@graphql-codegen/typescript-operations": "^2.4.2",
+    "@graphql-codegen/typescript-resolvers": "^2.6.6",
+    "@types/node": "^16",
+    "graphql": "^16.5.0",
     "pg": "^8.5.0"
   },
   "peerDependencies": {

package/src/acl/VariableInjector.ts

@@ -10,31 +10,16 @@ export class VariableInjector {
 		return predicateDefinitionProcessor.process(entity, where, {
 			handleColumn: ({ value }) => {
 				if (typeof value === 'string') {
-					return this.createCondition(this.variables[value] || undefined)
+					return this.variables[value] ?? { never: true }
 				}
 				return value as Input.Condition
 			},
 			handleRelation: ({ value, targetEntity }) => {
 				if (typeof value === 'string') {
-					return { [targetEntity.primary]: this.createCondition(this.variables[value] || undefined) }
+					return { [targetEntity.primary]: this.variables[value] ?? { never: true } }
 				}
 				return value
 			},
 		})
 	}
-
-	private createCondition(variable: Acl.VariableMapEntry | undefined): Input.Condition {
-		if (variable === undefined || variable.value.length === 0) {
-			return { never: true }
-		}
-
-		const { value, definition } = variable
-		if (definition.type === Acl.VariableType.condition) {
-			if (value.length === 1) {
-				return value[0] as Input.Condition
-			}
-			return { or: value as Input.Condition[] }
-		}
-		return { in: value as (string | number)[] }
-	}
 }

package/src/acl/VariableUtils.ts

@@ -1,41 +1,20 @@
-import { Acl } from '@contember/schema'
-import { getRoleVariables } from '@contember/schema-utils'
+import { Acl, Input } from '@contember/schema'
+import { getRoleVariables, ParsedMembership } from '@contember/schema-utils'
 
-type Memberships = readonly { role: string; variables: readonly { name: string; values: readonly string[] }[] }[]
 
 export const createAclVariables = (
 	aclSchema: Acl.Schema,
-	identity: {
-		identityId: string
-		personId: string | null
-		memberships: Memberships
-	},
+	memberships: readonly ParsedMembership[],
 ): Acl.VariablesMap => {
 
-	const variablesEntries = identity.memberships.flatMap(
+	const variablesEntries = memberships.flatMap(
 		membership => {
 			const roleVariables = getRoleVariables(membership.role, aclSchema)
-			const membershipVariablesMap = Object.fromEntries(membership.variables.map(it => [it.name, it.values]))
+			const membershipVariablesMap = Object.fromEntries(membership.variables.map(it => [it.name, it.condition]))
 
-			return Object.entries(roleVariables).map(([name, def]): [string, Acl.VariableMapEntry] => {
+			return Object.keys(roleVariables).map((name): [string, Input.Condition] => {
 				const prefixed = prefixVariable(membership.role, name)
-				const value = (() => {
-					switch (def.type) {
-						case Acl.VariableType.entity:
-							return membershipVariablesMap[name] ?? []
-						case Acl.VariableType.predefined:
-							switch (def.value) {
-								case 'identityID':
-									return [identity.identityId]
-								case 'personID':
-									return identity.personId ? [identity.personId] : []
-							}
-							throw new Error(`Unknown predefined variable ${def.value}`)
-						case Acl.VariableType.condition:
-							return (membershipVariablesMap[name] ?? []).map(it => JSON.parse(it))
-					}
-				})()
-				return [prefixed, { value: value, definition: def }]
+				return [prefixed, membershipVariablesMap[name] ?? { never: true }]
 			})
 		},
 	)

package/src/input-validation/EntityRulesResolver.ts

@@ -35,7 +35,7 @@ export class EntityRulesResolver {
 
 	public getEntityRules(entityName: string): Validation.EntityRules {
 		const definedRules = this.validationSchema[entityName] || {}
-		const fieldsNotNullFlag = acceptEveryFieldVisitor(this.model, entityName, new NotNullFieldsVisitor())
+		const fieldsNotNullFlag = acceptEveryFieldVisitor(this.model, entityName, new RequiredFieldsVisitor())
 		const notNullFields = Object.keys(filterObject(fieldsNotNullFlag, (field, val) => val))
 		return notNullFields.reduce(
 			(entityRules, field) => ({
@@ -50,9 +50,9 @@ export class EntityRulesResolver {
 	}
 }
 
-class NotNullFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Model.ColumnVisitor<boolean> {
+class RequiredFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Model.ColumnVisitor<boolean> {
 	visitColumn(entity: Model.Entity, column: Model.AnyColumn): boolean {
-		return !column.nullable
+		return !column.nullable && typeof column.default === 'undefined' && !column.sequence
 	}
 
 	visitManyHasManyInverse(): boolean {

package/src/input-validation/ValidationContext.ts

@@ -10,7 +10,7 @@ namespace ValidationContext {
 	}
 
 	export type NodeType = Value.Object
-	export type ValueType = Value.FieldValue
+	export type ValueType = Value.FieldValue | undefined
 
 	export enum NodeContextType {
 		value = 'value',
@@ -69,7 +69,7 @@ namespace ValidationContext {
 
 	export const createSingleNodeContext = (
 		parent: NodeContext | ValueContext,
-		value: object | null | string | number | boolean,
+		value: ValueType,
 	): NodeContext | ValueContext => {
 		if (Array.isArray(value)) {
 			throw new Error('Nested arrays are not allowed')

package/src/introspection/content-schema.types.ts

@@ -1,9 +1,8 @@
-import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'
 export type Maybe<T> = T | null
+export type InputMaybe<T> = Maybe<T>
 export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
 export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
 export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
-export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
 	ID: string
@@ -14,30 +13,29 @@ export type Scalars = {
 	Json: any
 }
 
-
 export type Query = {
 	readonly __typename?: 'Query'
 	readonly schema?: Maybe<_Schema>
 }
 
-export type _Argument = _ValidatorArgument | _PathArgument | _LiteralArgument
+export type _Argument = _LiteralArgument | _PathArgument | _ValidatorArgument
 
 export type _Column = _Field & {
 	readonly __typename?: '_Column'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly enumName?: Maybe<Scalars['String']>
 	readonly defaultValue?: Maybe<Scalars['Json']>
+	readonly enumName?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable: Scalars['Boolean']
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export type _Entity = {
 	readonly __typename?: '_Entity'
-	readonly name: Scalars['String']
 	readonly customPrimaryAllowed: Scalars['Boolean']
 	readonly fields: ReadonlyArray<_Field>
+	readonly name: Scalars['String']
 	readonly unique: ReadonlyArray<_UniqueConstraint>
 }
 
@@ -49,9 +47,9 @@ export type _Enum = {
 
 export type _Field = {
 	readonly name: Scalars['String']
-	readonly type: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
@@ -61,15 +59,15 @@ export type _LiteralArgument = {
 }
 
 export enum _OnDeleteBehaviour {
-	Restrict = 'restrict',
 	Cascade = 'cascade',
+	Restrict = 'restrict',
 	SetNull = 'setNull'
 }
 
 export type _OrderBy = {
 	readonly __typename?: '_OrderBy'
-	readonly path: ReadonlyArray<Scalars['String']>
 	readonly direction: _OrderByDirection
+	readonly path: ReadonlyArray<Scalars['String']>
 }
 
 export enum _OrderByDirection {
@@ -84,23 +82,23 @@ export type _PathArgument = {
 
 export type _Relation = _Field & {
 	readonly __typename?: '_Relation'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly side: _RelationSide
-	readonly targetEntity: Scalars['String']
-	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly inversedBy?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly onDelete?: Maybe<_OnDeleteBehaviour>
-	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
 	readonly orderBy?: Maybe<ReadonlyArray<_OrderBy>>
+	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
+	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly side: _RelationSide
+	readonly targetEntity: Scalars['String']
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export enum _RelationSide {
-	Owning = 'owning',
-	Inverse = 'inverse'
+	Inverse = 'inverse',
+	Owning = 'owning'
 }
 
 export type _Rule = {
@@ -116,8 +114,8 @@ export type _RuleMessage = {
 
 export type _Schema = {
 	readonly __typename?: '_Schema'
-	readonly enums: ReadonlyArray<_Enum>
 	readonly entities: ReadonlyArray<_Entity>
+	readonly enums: ReadonlyArray<_Enum>
 }
 
 export type _UniqueConstraint = {
@@ -127,276 +125,11 @@ export type _UniqueConstraint = {
 
 export type _Validator = {
 	readonly __typename?: '_Validator'
-	readonly operation: Scalars['String']
 	readonly arguments: ReadonlyArray<_Argument>
+	readonly operation: Scalars['String']
 }
 
 export type _ValidatorArgument = {
 	readonly __typename?: '_ValidatorArgument'
 	readonly validator: Scalars['Int']
 }
-
-
-
-export type ResolverTypeWrapper<T> = Promise<T> | T
-
-
-export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	fragment: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-
-export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	selectionSet: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
-  | ResolverFn<TResult, TParent, TContext, TArgs>
-  | StitchingResolver<TResult, TParent, TContext, TArgs>
-
-export type ResolverFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Promise<TResult> | TResult
-
-export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>
-
-export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>
-	resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>
-}
-
-export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>
-	resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>
-}
-
-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
-
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
-
-export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
-	parent: TParent,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Maybe<TTypes> | Promise<Maybe<TTypes>>
-
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
-
-export type NextResolverFn<T> = () => Promise<T>
-
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
-	next: NextResolverFn<TResult>,
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-/** Mapping between all available schema types and the resolvers types */
-export type ResolversTypes = {
-	Json: ResolverTypeWrapper<Scalars['Json']>
-	Query: ResolverTypeWrapper<{}>
-	_Argument: ResolversTypes['_ValidatorArgument'] | ResolversTypes['_PathArgument'] | ResolversTypes['_LiteralArgument']
-	_Column: ResolverTypeWrapper<_Column>
-	String: ResolverTypeWrapper<Scalars['String']>
-	Boolean: ResolverTypeWrapper<Scalars['Boolean']>
-	_Entity: ResolverTypeWrapper<_Entity>
-	_Enum: ResolverTypeWrapper<_Enum>
-	_Field: ResolversTypes['_Column'] | ResolversTypes['_Relation']
-	_LiteralArgument: ResolverTypeWrapper<_LiteralArgument>
-	_OnDeleteBehaviour: _OnDeleteBehaviour
-	_OrderBy: ResolverTypeWrapper<_OrderBy>
-	_OrderByDirection: _OrderByDirection
-	_PathArgument: ResolverTypeWrapper<_PathArgument>
-	_Relation: ResolverTypeWrapper<_Relation>
-	_RelationSide: _RelationSide
-	_Rule: ResolverTypeWrapper<_Rule>
-	Int: ResolverTypeWrapper<Scalars['Int']>
-	_RuleMessage: ResolverTypeWrapper<_RuleMessage>
-	_Schema: ResolverTypeWrapper<_Schema>
-	_UniqueConstraint: ResolverTypeWrapper<_UniqueConstraint>
-	_Validator: ResolverTypeWrapper<Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversTypes['_Argument']> }>
-	_ValidatorArgument: ResolverTypeWrapper<_ValidatorArgument>
-}
-
-/** Mapping between all available schema types and the resolvers parents */
-export type ResolversParentTypes = {
-	Json: Scalars['Json']
-	Query: {}
-	_Argument: ResolversParentTypes['_ValidatorArgument'] | ResolversParentTypes['_PathArgument'] | ResolversParentTypes['_LiteralArgument']
-	_Column: _Column
-	String: Scalars['String']
-	Boolean: Scalars['Boolean']
-	_Entity: _Entity
-	_Enum: _Enum
-	_Field: ResolversParentTypes['_Column'] | ResolversParentTypes['_Relation']
-	_LiteralArgument: _LiteralArgument
-	_OrderBy: _OrderBy
-	_PathArgument: _PathArgument
-	_Relation: _Relation
-	_Rule: _Rule
-	Int: Scalars['Int']
-	_RuleMessage: _RuleMessage
-	_Schema: _Schema
-	_UniqueConstraint: _UniqueConstraint
-	_Validator: Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversParentTypes['_Argument']> }
-	_ValidatorArgument: _ValidatorArgument
-}
-
-export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
-	name: 'Json'
-}
-
-export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
-	schema?: Resolver<Maybe<ResolversTypes['_Schema']>, ParentType, ContextType>
-}
-
-export type _ArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Argument'] = ResolversParentTypes['_Argument']> = {
-	__resolveType: TypeResolveFn<'_ValidatorArgument' | '_PathArgument' | '_LiteralArgument', ParentType, ContextType>
-}
-
-export type _ColumnResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Column'] = ResolversParentTypes['_Column']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	enumName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	defaultValue?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	nullable?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EntityResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Entity'] = ResolversParentTypes['_Entity']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	customPrimaryAllowed?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	fields?: Resolver<ReadonlyArray<ResolversTypes['_Field']>, ParentType, ContextType>
-	unique?: Resolver<ReadonlyArray<ResolversTypes['_UniqueConstraint']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EnumResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Enum'] = ResolversParentTypes['_Enum']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	values?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _FieldResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Field'] = ResolversParentTypes['_Field']> = {
-	__resolveType: TypeResolveFn<'_Column' | '_Relation', ParentType, ContextType>
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-}
-
-export type _LiteralArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_LiteralArgument'] = ResolversParentTypes['_LiteralArgument']> = {
-	value?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _OrderByResolvers<ContextType = any, ParentType extends ResolversParentTypes['_OrderBy'] = ResolversParentTypes['_OrderBy']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	direction?: Resolver<ResolversTypes['_OrderByDirection'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _PathArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_PathArgument'] = ResolversParentTypes['_PathArgument']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Relation'] = ResolversParentTypes['_Relation']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	side?: Resolver<ResolversTypes['_RelationSide'], ParentType, ContextType>
-	targetEntity?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	ownedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	inversedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	onDelete?: Resolver<Maybe<ResolversTypes['_OnDeleteBehaviour']>, ParentType, ContextType>
-	orphanRemoval?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	orderBy?: Resolver<Maybe<ReadonlyArray<ResolversTypes['_OrderBy']>>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Rule'] = ResolversParentTypes['_Rule']> = {
-	message?: Resolver<Maybe<ResolversTypes['_RuleMessage']>, ParentType, ContextType>
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleMessageResolvers<ContextType = any, ParentType extends ResolversParentTypes['_RuleMessage'] = ResolversParentTypes['_RuleMessage']> = {
-	text?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _SchemaResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Schema'] = ResolversParentTypes['_Schema']> = {
-	enums?: Resolver<ReadonlyArray<ResolversTypes['_Enum']>, ParentType, ContextType>
-	entities?: Resolver<ReadonlyArray<ResolversTypes['_Entity']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _UniqueConstraintResolvers<ContextType = any, ParentType extends ResolversParentTypes['_UniqueConstraint'] = ResolversParentTypes['_UniqueConstraint']> = {
-	fields?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Validator'] = ResolversParentTypes['_Validator']> = {
-	operation?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	arguments?: Resolver<ReadonlyArray<ResolversTypes['_Argument']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_ValidatorArgument'] = ResolversParentTypes['_ValidatorArgument']> = {
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type Resolvers<ContextType = any> = {
-	Json?: GraphQLScalarType
-	Query?: QueryResolvers<ContextType>
-	_Argument?: _ArgumentResolvers<ContextType>
-	_Column?: _ColumnResolvers<ContextType>
-	_Entity?: _EntityResolvers<ContextType>
-	_Enum?: _EnumResolvers<ContextType>
-	_Field?: _FieldResolvers<ContextType>
-	_LiteralArgument?: _LiteralArgumentResolvers<ContextType>
-	_OrderBy?: _OrderByResolvers<ContextType>
-	_PathArgument?: _PathArgumentResolvers<ContextType>
-	_Relation?: _RelationResolvers<ContextType>
-	_Rule?: _RuleResolvers<ContextType>
-	_RuleMessage?: _RuleMessageResolvers<ContextType>
-	_Schema?: _SchemaResolvers<ContextType>
-	_UniqueConstraint?: _UniqueConstraintResolvers<ContextType>
-	_Validator?: _ValidatorResolvers<ContextType>
-	_ValidatorArgument?: _ValidatorArgumentResolvers<ContextType>
-}
-
-
-/**
- * @deprecated
- * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.
- */
-export type IResolvers<ContextType = any> = Resolvers<ContextType>

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -7,7 +7,7 @@ import {
 	GraphQLResolveInfo,
 	isListType,
 	isNonNullType,
-	isObjectType,
+	isObjectType, Kind,
 } from 'graphql'
 import { SelectionSetNode } from 'graphql/language/ast'
 import { getArgumentValues } from 'graphql/execution/values'
@@ -67,13 +67,13 @@ export class GraphQlQueryAstFactory {
 	): AnyNode[] {
 		const fields: ObjectNode | FieldNode[] = []
 		for (const subNode of selectionSet.selections) {
-			if (isIt<GraphQlFieldNode>(subNode, 'kind', 'Field')) {
+			if (isIt<GraphQlFieldNode>(subNode, 'kind', Kind.FIELD)) {
 				const field = this.createFromNode(info, parentType, subNode, path, filter)
 				if (field === null) {
 					continue
 				}
 				fields.push(field)
-			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', 'FragmentSpread')) {
+			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', Kind.FRAGMENT_SPREAD)) {
 				const fragmentDefinition = info.fragments[subNode.name.value]
 				if (!fragmentDefinition) {
 					throw new Error(`GraphQlQueryAstFactory: Fragment definition ${subNode.name.value} not found`)

package/tests/cases/integration/graphQlDb/insert/insertSequence.test.ts

@@ -0,0 +1,34 @@
+import { SchemaDefinition as def } from '@contember/schema-definition'
+import { GQL } from '../../../../src/tags'
+import { test } from 'vitest'
+import { executeDbTest } from '@contember/engine-api-tester'
+
+namespace SeqModel {
+	export class Order {
+		seqId = def.intColumn().sequence().notNull()
+	}
+}
+
+test('insert author with id', async () => {
+	const schema = def.createModel(SeqModel)
+	await executeDbTest({
+		schema: schema,
+		query: GQL`
+          mutation {
+              createOrder(data: {}) {
+                  node {
+                  	seqId
+                  }
+              }
+          }`,
+		seed: [],
+		return: {
+			createOrder: {
+				node: {
+					seqId: 1,
+				},
+			},
+		},
+	})
+})
+

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -32,12 +32,7 @@ test('delete post with acl', async () => {
 			},
 		},
 		variables: {
-			locale_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			locale_variable: { in: ['cs'] },
 		},
 		executes: [
 			...sqlTransaction([