@contember/engine-content-api 2.0.2 → 2.0.3

package/package.json

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

package/src/ExecutionContainer.ts

@@ -166,8 +166,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))
 			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema, schemaDatabaseMetadata }) => {

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)
 	}
 }

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/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\"}}]})`,
+				},
+			},
+		},
+	})
+})