@contember/engine-content-api 2.1.0-alpha.3 → 2.1.0-alpha.30

package/graphql.codegen.yml

@@ -12,4 +12,4 @@ generates:
       - "typescript-operations"
 hooks:
   afterAllFileWrite:
-    - bun run -T eslint --fix
+    - bun run eslint --fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "2.1.0-alpha.3",
+  "version": "2.1.0-alpha.30",
   "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.1.0-alpha.3",
-    "@contember/dic": "2.1.0-alpha.3",
-    "@contember/graphql-utils": "2.1.0-alpha.3",
-    "@contember/logger": "2.1.0-alpha.3",
-    "@contember/schema": "2.1.0-alpha.3",
-    "@contember/schema-definition": "2.1.0-alpha.3",
-    "@contember/schema-utils": "2.1.0-alpha.3",
+    "@contember/database": "2.1.0-alpha.30",
+    "@contember/dic": "2.1.0-alpha.30",
+    "@contember/graphql-utils": "2.1.0-alpha.30",
+    "@contember/logger": "2.1.0-alpha.30",
+    "@contember/schema": "2.1.0-alpha.30",
+    "@contember/schema-definition": "2.1.0-alpha.30",
+    "@contember/schema-utils": "2.1.0-alpha.30",
     "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "2.1.0-alpha.3",
-    "@contember/schema-definition": "2.1.0-alpha.3",
+    "@contember/database-tester": "2.1.0-alpha.30",
+    "@contember/schema-definition": "2.1.0-alpha.30",
     "@types/node": "^20.17.22",
     "graphql": "^16.9.0",
     "pg": "^8.12.0"

package/src/ExecutionContainer.ts

@@ -31,7 +31,7 @@ import { Client, DatabaseMetadata, SelectBuilder as DbSelectBuilder } from '@con
 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'
+import { WhereOptimizer, WhereOptimizerOptions } from './mapper/select/optimizer/WhereOptimizer'
 import { ConditionOptimizer } from './mapper/select/optimizer/ConditionOptimizer'
 import { GraphQlQueryAstFactory, MutationResolver, ReadResolver, ValidationResolver } from './resolvers'
 import {
@@ -54,6 +54,7 @@ export type ExecutionContainerArgs = {
 	systemSchema: string
 	project: { slug: string }
 	stage: { id: string; slug: string }
+	userInfo: { ipAddress: string | null; userAgent: string | null }
 }
 
 export interface ExecutionContainer {
@@ -71,6 +72,7 @@ export class ExecutionContainerFactory {
 
 	constructor(
 		private readonly providers: Providers,
+		private readonly whereOptimizerOptions?: WhereOptimizerOptions,
 	) {
 	}
 
@@ -79,7 +81,7 @@ export class ExecutionContainerFactory {
 		return this.hooks.reduce((acc, cb) => cb(acc), builder)
 	}
 
-	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, schemaMeta, systemSchema, stage, project, schemaDatabaseMetadata }: ExecutionContainerArgs) {
+	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, schemaMeta, systemSchema, stage, project, schemaDatabaseMetadata, userInfo }: ExecutionContainerArgs) {
 		return new Builder({})
 			.addService('systemSchema', () =>
 				systemSchema)
@@ -95,6 +97,8 @@ export class ExecutionContainerFactory {
 				schemaMeta)
 			.addService('schemaDatabaseMetadata', () =>
 				schemaDatabaseMetadata)
+			.addService('userInfo', () =>
+				userInfo)
 			.addService('providers', () =>
 				this.providers)
 			.addService('variableInjector', ({ schema }) =>
@@ -110,7 +114,7 @@ export class ExecutionContainerFactory {
 			.addService('pathFactory', () =>
 				new PathFactory())
 			.addService('whereOptimized', ({ schema }) =>
-				new WhereOptimizer(schema.model, new ConditionOptimizer()))
+				new WhereOptimizer(schema.model, new ConditionOptimizer(), this.whereOptimizerOptions))
 			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
 				new WhereBuilder(
 					schema.model,
@@ -168,8 +172,8 @@ export class ExecutionContainerFactory {
 				new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
 			.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
 				new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
-			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema, schemaDatabaseMetadata }) =>
-				new Updater(schema.model, schemaDatabaseMetadata, predicateFactory, updateBuilderFactory))
+			.addService('updater', ({ updateBuilderFactory, schema }) =>
+				new Updater(schema.model, updateBuilderFactory))
 			.addService('inserter', ({  insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
 				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 }) => {

package/src/index.ts

@@ -25,7 +25,8 @@ export {
 	type ExecutionContainer,
 	type ExecutionContainerBuilder,
 	Path,
-	WhereBuilder,
+	type WhereBuilder,
+	type JoinBuilder,
 	PathFactory,
 	ExecutionContainerFactory,
 	type ExecutionContainerHook,

package/src/mapper/Result.ts

@@ -178,7 +178,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 	hints: MutationResultHint[] = []
 	message: string
 
-	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.Where) {
+	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.OptionalWhere) {
 		this.message = 'for input ' + JSON.stringify(where)
 	}
 }
@@ -202,6 +202,6 @@ export const prependPath = (path: Path, results: MutationResultList): MutationRe
 	}))
 
 export const getInsertPrimary = (result: MutationResultList) =>
-	result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
+	!result.some(it => it.error) && result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
 		? result[0].primary
 		: undefined

package/src/mapper/select/ConditionBuilder.ts

@@ -49,12 +49,18 @@ export class ConditionBuilder {
 			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
+			includes: (builder, value: any) => {
+				if (columnType.type === Model.ColumnType.Json) {
+					// For JSON columns, use @> operator to check if JSON contains the value
+					return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ?::jsonb`, JSON.stringify(value))
+				} else {
+					// For array columns, use @> operator with array casting
+					const cast = columnType.type === Model.ColumnType.Enum
+						? `${Compiler.SCHEMA_PLACEHOLDER}."${columnType.columnType}"`
+						: columnType.columnType
 
-				return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ARRAY[?]::${cast}[]`, value)
+					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),

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -18,16 +18,25 @@ export interface WhereOptimizationHints {
 
 type OptimizedOperand = Input.OptionalWhere | undefined | boolean
 
+export type WhereOptimizerOptions = {
+	disable?: boolean
+	maxCrossOptimizationInput?: number
+}
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
 	constructor(
 		private readonly model: Model.Schema,
 		private readonly conditionOptimizer: ConditionOptimizer,
+		private readonly options?: WhereOptimizerOptions,
 	) {
 	}
 
 	public optimize(where: Input.OptionalWhere, entity: Model.Entity, { relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
+		if (this.options?.disable) {
+			return where
+		}
 		let processedRelationPath: ExtendedRelationContext[] = []
 		for (const i in relationPath) {
 			const el = relationPath[i]
@@ -134,7 +143,7 @@ export class WhereOptimizer {
 	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
 		let result: (Input.OptionalWhere | boolean)[] = operands
 		let copied = false
-		const count = result.length
+		const count = Math.min(result.length, this.options?.maxCrossOptimizationInput ?? 50)
 		for (let i = 0; i < count; i++) {
 			for (let j = 0; j < count; j++) {
 				const a = result[j]

package/src/mapper/update/Updater.ts

@@ -1,21 +1,17 @@
 import { SqlUpdateInputProcessor, SqlUpdateInputProcessorResult } from './SqlUpdateInputProcessor'
 import { UpdateInputVisitor } from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
-import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
+import { MutationEntryNotFoundError, MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
-import { DatabaseMetadata } from '@contember/database'
 import { MapperInput } from '../types'
 
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: DatabaseMetadata,
-		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}
 
@@ -66,6 +62,21 @@ export class Updater {
 		const result = await updateBuilder.execute(mapper)
 
 		if (!result.executed) {
+			if (filter && Object.keys(filter).length > 0) {
+				// direct update was not invoked, but we still need to check if the row matches the filter
+				const where: Input.OptionalWhere = {
+					and: [
+						filter,
+						{
+							[entity.primary]: { eq: primaryValue },
+						},
+					],
+				}
+				const count = await mapper.count(entity, where)
+				if (!count) {
+					return [new MutationEntryNotFoundError([], where)]
+				}
+			}
 			resultList.unshift(new MutationNothingToDo([], NothingToDoReason.noData))
 		} else if (result.affectedRows !== 1) {
 			return [new MutationNoResultError([])]

package/src/resolvers/RefreshViewResolver.ts

@@ -1,7 +1,6 @@
 import { Schema } from '@contember/schema'
 import { MapperFactory } from '../mapper'
 import { wrapIdentifier } from '@contember/database'
-import { Authorizator } from '../acl'
 
 export class RefreshViewResolver {
 	constructor(
@@ -10,13 +9,14 @@ export class RefreshViewResolver {
 	) {
 	}
 
-	public async resolve(entity: string): Promise<{ ok: boolean }> {
+	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`)
 		}
-		await mapper.db.query(`REFRESH MATERIALIZED VIEW ${wrapIdentifier(entityModel.tableName)}`)
+		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/ConditionTypeProvider.ts

@@ -60,6 +60,9 @@ export class ConditionTypeProvider {
 						conditions.lte = { type: type }
 						conditions.gt = { type: type }
 						conditions.gte = { type: type }
+					} else {
+						// For JSON columns, add the includes operator
+						conditions.includes = { type: type }
 					}
 					if (column.type === Model.ColumnType.String) {
 						conditions.contains = { type: GraphQLString }

package/src/schema/RefreshViewMutationProvider.ts

@@ -1,5 +1,5 @@
 import { Model } from '@contember/schema'
-import { GraphQLBoolean, GraphQLEnumType, GraphQLFieldConfig, GraphQLObjectType } from 'graphql'
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFieldConfig, GraphQLInputObjectType, GraphQLObjectType } from 'graphql'
 import { Context } from '../types'
 import { Authorizator } from '../acl'
 
@@ -22,6 +22,12 @@ export class RefreshViewMutationProvider {
 			values: Object.fromEntries(materializedViews.map(it => [it.name, { value: it.name }])),
 		})
 
+		const refreshViewOptions = new GraphQLInputObjectType({
+			name: 'RefreshMaterializedViewOptions',
+			fields: {
+				concurrently: { type: GraphQLBoolean },
+			},
+		})
 		return {
 			type: new GraphQLObjectType({
 				name: 'RefreshMaterializedViewResponse',
@@ -31,9 +37,10 @@ export class RefreshViewMutationProvider {
 			}),
 			args: {
 				name: { type: materializedViewsEnum },
+				options: { type: refreshViewOptions },
 			},
 			resolve: async (parent, args, context) => {
-				return await context.executionContainer.refreshViewResolver.resolve(args.name)
+				return await context.executionContainer.refreshViewResolver.resolve(args.name, args.options)
 			},
 		}
 	}

package/tests/cases/integration/graphQlRequests/insert/subOperationFail.test.ts

@@ -0,0 +1,105 @@
+import { test } from 'bun:test'
+import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
+import { c, createSchema } from '@contember/schema-definition'
+import { Model } from '@contember/schema'
+import { GQL, SQL } from '../../../../src/tags'
+import { testUuid } from '../../../../src/testUuid'
+
+namespace TestModel {
+	export class Article {
+		content = c.manyHasOne(ArticleContent)
+	}
+
+	export class ArticleContent {
+		locales = c.oneHasMany(ArticleContentLocale, 'content')
+	}
+
+	export class ArticleContentLocale {
+		content = c.manyHasOne(ArticleContent, 'locales')
+		title = c.stringColumn()
+		locale = c.stringColumn()
+	}
+}
+
+test('failed to insert in sub-operation', async () => {
+	await execute({
+		schema: createSchema(TestModel).model,
+		query: GQL`
+          mutation {
+              createArticle(data: {content: {create: {locales: [{create: {locale: "en", title: "Title"}}]}}}) {
+                  ok
+              }
+          }`,
+		executes: [
+			...failedTransaction([
+				{
+					sql: SQL`with "root_" as (select ? :: uuid as "id") insert into  "public"."article_content" ("id") select "root_"."id"  from "root_"  returning "id"`,
+					parameters: [testUuid(2)],
+					response: {
+						rows: [{ id: testUuid(2) }],
+					},
+				},
+				{
+					sql: SQL`with "root_" as (select ? :: uuid as "id", ? :: text as "title", ? :: text as "locale", ? :: uuid as "content_id") insert into  "public"."article_content_locale" ("id", "title", "locale", "content_id") select "root_"."id", "root_"."title", "root_"."locale", "root_"."content_id"  from "root_"  returning "id"`,
+					parameters: [testUuid(3), 'Title', 'en', testUuid(2)],
+					response: {
+						rows: [],
+					},
+				},
+			]),
+		],
+		return: {
+			data: {
+				createArticle: {
+					ok: false,
+				},
+			},
+		},
+	})
+})
+
+
+test('failed to insert in sub-operation in update', async () => {
+	await execute({
+		schema: createSchema(TestModel).model,
+		query: GQL`
+          mutation {
+              updateArticle(by: {id: "${testUuid(10)}"}, data: {content: {create: {locales: [{create: {locale: "en", title: "Title"}}]}}}) {
+                  ok
+              }
+          }`,
+		executes: [
+			...failedTransaction([
+				{
+					sql: `select "root_"."id"  from "public"."article" as "root_"  where "root_"."id" = ?`,
+					parameters: [testUuid(10)],
+					response: {
+						rows: [{ id: testUuid(10) }],
+					},
+				},
+				{
+					sql: SQL`with "root_" as (select ? :: uuid as "id") insert into  "public"."article_content" ("id") select "root_"."id"  from "root_"  returning "id"`,
+					parameters: [testUuid(1)],
+					response: {
+						rows: [{ id: testUuid(1) }],
+					},
+				},
+				{
+					sql: SQL`with "root_" as (select ? :: uuid as "id", ? :: text as "title", ? :: text as "locale", ? :: uuid as "content_id") insert into  "public"."article_content_locale" ("id", "title", "locale", "content_id") select "root_"."id", "root_"."title", "root_"."locale", "root_"."content_id"  from "root_"  returning "id"`,
+					parameters: [testUuid(2), 'Title', 'en', testUuid(1)],
+					response: {
+						rows: [],
+					},
+				},
+			]),
+		],
+		return: {
+			data: {
+				updateArticle: {
+					ok: false,
+				},
+			},
+		},
+	})
+})
+

package/tests/cases/integration/graphQlRequests/update/additionalFilter.test.ts

@@ -1,6 +1,6 @@
 import { test } from 'bun:test'
-import { execute, sqlTransaction } from '../../../../src/test'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
+import { c, createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
@@ -59,3 +59,52 @@ test('applies a filter', async () => {
 	})
 })
 
+
+namespace FilterModel {
+	export class Article {
+		publishedAt = c.dateTimeColumn()
+		tags = c.manyHasMany(Tag)
+	}
+
+	export class Tag {
+		name = c.stringColumn()
+	}
+}
+
+test('applies a filter with only relation update', async () => {
+	await execute({
+		schema: createSchema(FilterModel).model,
+		query: GQL`mutation {
+        updateArticle(
+            by: {id: "${testUuid(1)}"},
+            filter: {publishedAt: {isNull: false}},
+            data: {tags: {connect: {id: "${testUuid(2)}"}}}
+          ) {
+          ok
+          errorMessage
+        }
+      }`,
+		executes: [
+			...failedTransaction([
+				{
+					sql: SQL`select "root_"."id" from "public"."article" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
+				{
+					sql: SQL`select count(*) as "row_count"  from "public"."article" as "root_"  where not("root_"."published_at" is null) and "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ row_count: 0 }] },
+				},
+			]),
+		],
+		return: {
+			data: {
+				updateArticle: {
+					ok: false,
+					errorMessage: `Execution has failed:\nunknown field: NotFoundOrDenied (for input {\"and\":[{\"publishedAt\":{\"isNull\":false}},{\"id\":{\"eq\":\"123e4567-e89b-12d3-a456-000000000001\"}}]})`,
+				},
+			},
+		},
+	})
+})

package/tests/cases/integration/graphQlSchema/schema-column-types.gql

@@ -204,6 +204,7 @@ input JsonCondition {
   not: JsonCondition
   null: Boolean
   isNull: Boolean
+  includes: Json
 }
 
 input TimeCondition {

package/tests/src/test.ts

@@ -113,6 +113,7 @@ export const execute = async (test: Test) => {
 					stage: { id: '00000000-0000-0000-0000-000000000000', slug: 'live' },
 					project: { slug: 'test' },
 					schemaDatabaseMetadata: emptyDatabaseMetadata,
+					userInfo: { ipAddress: null, userAgent: null },
 				}),
 			timer: (label: any, cb: any) => cb(),
 		},