@contember/engine-actions 2.0.0-alpha.9 → 2.0.0-beta.2

package/{graphql-actions.codegen.yml → graphql.codegen.yml}

@@ -18,4 +18,4 @@ generates:
       - "typescript-resolvers"
 hooks:
   afterAllFileWrite:
-    - eslint --fix
+    - yarn run -T eslint --fix

package/package.json

@@ -21,39 +21,33 @@
       }
     }
   },
-  "scripts": {
-    "generate": "gql-gen --config graphql-actions.codegen.yml"
-  },
   "dependencies": {
-    "@contember/authorization": "2.0.0-alpha.9",
-    "@contember/database": "2.0.0-alpha.9",
-    "@contember/database-migrations": "2.0.0-alpha.9",
-    "@contember/engine-common": "2.0.0-alpha.9",
-    "@contember/engine-content-api": "2.0.0-alpha.9",
-    "@contember/engine-http": "2.0.0-alpha.9",
-    "@contember/engine-plugins": "2.0.0-alpha.9",
-    "@contember/engine-system-api": "2.0.0-alpha.9",
-    "@contember/engine-tenant-api": "2.0.0-alpha.9",
-    "@contember/graphql-utils": "2.0.0-alpha.9",
-    "@contember/logger": "2.0.0-alpha.9",
-    "@contember/schema": "2.0.0-alpha.9",
-    "@contember/schema-utils": "2.0.0-alpha.9",
-    "@contember/typesafe": "2.0.0-alpha.9",
-    "@graphql-tools/schema": "^10.0.0",
+    "@contember/authorization": "2.0.0-beta.2",
+    "@contember/database": "2.0.0-beta.2",
+    "@contember/database-migrations": "2.0.0-beta.2",
+    "@contember/engine-common": "2.0.0-beta.2",
+    "@contember/engine-content-api": "2.0.0-beta.2",
+    "@contember/engine-http": "2.0.0-beta.2",
+    "@contember/engine-plugins": "2.0.0-beta.2",
+    "@contember/engine-system-api": "2.0.0-beta.2",
+    "@contember/engine-tenant-api": "2.0.0-beta.2",
+    "@contember/graphql-utils": "2.0.0-beta.2",
+    "@contember/logger": "2.0.0-beta.2",
+    "@contember/schema": "2.0.0-beta.2",
+    "@contember/schema-utils": "2.0.0-beta.2",
+    "@contember/typesafe": "2.0.0-beta.2",
+    "@graphql-tools/schema": "^10.0.7",
     "graphql-tag": "^2.12.6"
   },
   "devDependencies": {
-    "@graphql-codegen/cli": "^5.0.0",
-    "@graphql-codegen/typescript": "^4.0.1",
-    "@graphql-codegen/typescript-operations": "^4.0.1",
-    "@graphql-codegen/typescript-resolvers": "^4.0.1",
-    "@types/ws": "^8.5.9",
-    "graphql": "^16.8.1"
+    "@types/bun": "^1.1.10",
+    "@types/ws": "^8.5.12",
+    "graphql": "^16.9.0"
   },
   "peerDependencies": {
     "graphql": ">= 14.6.0",
     "pg": "^8.5.0"
   },
   "type": "module",
-  "version": "2.0.0-alpha.9"
-}
+  "version": "2.0.0-beta.2"
+}

package/src/ActionsExecutionContainerHookFactory.ts

@@ -12,9 +12,9 @@ export class ActionsExecutionContainerHookFactory {
 
 	create(): ExecutionContainerHook {
 		return builder => {
-			return builder.setupService('mapperFactory', (mapperFactory, { whereBuilder, schema, pathFactory, systemSchema, providers, stage, project }) => {
+			return builder.setupService('mapperFactory', (mapperFactory, { whereBuilder, schema, pathFactory, systemSchema, providers, stage, project, schemaMeta }) => {
 				mapperFactory.hooks.push(mapper => {
-					const triggerPayloadPersister = new TriggerPayloadPersister(mapper, mapper.db.forSchema(systemSchema), providers, project.slug, stage.id, schema.id)
+					const triggerPayloadPersister = new TriggerPayloadPersister(mapper, mapper.db.forSchema(systemSchema), providers, project.slug, stage.id, schemaMeta.id)
 					const triggerPayloadBuilder = new TriggerPayloadBuilder(mapper)
 					const payloadManager = new TriggerPayloadManager(triggerPayloadBuilder, triggerPayloadPersister)
 					const changesFetcher = new TriggerIndirectChangesFetcher(mapper, whereBuilder, pathFactory)

package/src/dispatch/EventDispatcher.ts

@@ -29,7 +29,7 @@ export class EventDispatcher {
 	}
 
 	async processBatch({ db, contentSchemaResolver, logger }: ProcessBatchArgs): Promise<ProcessBatchResult> {
-		const schema = await contentSchemaResolver.getSchema(db)
+		const schema = (await contentSchemaResolver.getSchema({ db, normalize: true })).schema
 		const batch = await this.eventsRepository.fetchBatch(schema.actions, db.client)
 		const batchId = Math.random().toString().substring(2)
 		const batchLogger = logger.child({ loc: 'Actions.EventDispatcher', batchId })

package/src/graphql/schema/index.ts

@@ -4,39 +4,41 @@ 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 MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
 export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
-	ID: string
-	String: string
-	Boolean: boolean
-	Int: number
-	Float: number
-	DateTime: Date
-	Json: any
-	Uuid: String
+	ID: { input: string; output: string }
+	String: { input: string; output: string }
+	Boolean: { input: boolean; output: boolean }
+	Int: { input: number; output: number }
+	Float: { input: number; output: number }
+	DateTime: { input: Date; output: Date }
+	Json: { input: any; output: any }
+	Uuid: { input: String; output: String }
 }
 
 export type Event = {
 	readonly __typename?: 'Event'
-	readonly createdAt: Scalars['DateTime']
-	readonly id: Scalars['Uuid']
-	readonly lastStateChange: Scalars['DateTime']
-	readonly log: Scalars['Json']
-	readonly numRetries: Scalars['Int']
-	readonly payload: Scalars['Json']
-	readonly resolvedAt?: Maybe<Scalars['DateTime']>
-	readonly stage: Scalars['String']
+	readonly createdAt: Scalars['DateTime']['output']
+	readonly id: Scalars['Uuid']['output']
+	readonly lastStateChange: Scalars['DateTime']['output']
+	readonly log: Scalars['Json']['output']
+	readonly numRetries: Scalars['Int']['output']
+	readonly payload: Scalars['Json']['output']
+	readonly resolvedAt?: Maybe<Scalars['DateTime']['output']>
+	readonly stage: Scalars['String']['output']
 	readonly state: EventState
-	readonly target: Scalars['String']
-	readonly transactionId: Scalars['Uuid']
-	readonly visibleAt?: Maybe<Scalars['DateTime']>
+	readonly target: Scalars['String']['output']
+	readonly transactionId: Scalars['Uuid']['output']
+	readonly visibleAt?: Maybe<Scalars['DateTime']['output']>
 }
 
 export type EventArgs = {
 	/** Max 10000 */
-	readonly limit?: InputMaybe<Scalars['Int']>
-	readonly offset?: InputMaybe<Scalars['Int']>
+	readonly limit?: InputMaybe<Scalars['Int']['input']>
+	readonly offset?: InputMaybe<Scalars['Int']['input']>
 }
 
 export type EventState =
@@ -60,7 +62,7 @@ export type MutationSetVariablesArgs = {
 
 export type ProcessBatchResponse = {
 	readonly __typename?: 'ProcessBatchResponse'
-	readonly ok: Scalars['Boolean']
+	readonly ok: Scalars['Boolean']['output']
 }
 
 export type Query = {
@@ -104,18 +106,18 @@ export type SetVariablesMode =
 
 export type SetVariablesResponse = {
 	readonly __typename?: 'SetVariablesResponse'
-	readonly ok: Scalars['Boolean']
+	readonly ok: Scalars['Boolean']['output']
 }
 
 export type Variable = {
 	readonly __typename?: 'Variable'
-	readonly name: Scalars['String']
-	readonly value: Scalars['String']
+	readonly name: Scalars['String']['output']
+	readonly value: Scalars['String']['output']
 }
 
 export type VariableInput = {
-	readonly name: Scalars['String']
-	readonly value: Scalars['String']
+	readonly name: Scalars['String']['input']
+	readonly value: Scalars['String']['input']
 }
 
 
@@ -185,42 +187,44 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 	info: GraphQLResolveInfo
 ) => TResult | Promise<TResult>
 
+
+
 /** Mapping between all available schema types and the resolvers types */
 export type ResolversTypes = {
-	Boolean: ResolverTypeWrapper<Scalars['Boolean']>
-	DateTime: ResolverTypeWrapper<Scalars['DateTime']>
+	Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>
+	DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>
 	Event: ResolverTypeWrapper<Event>
 	EventArgs: EventArgs
 	EventState: EventState
-	Int: ResolverTypeWrapper<Scalars['Int']>
-	Json: ResolverTypeWrapper<Scalars['Json']>
+	Int: ResolverTypeWrapper<Scalars['Int']['output']>
+	Json: ResolverTypeWrapper<Scalars['Json']['output']>
 	Mutation: ResolverTypeWrapper<{}>
 	ProcessBatchResponse: ResolverTypeWrapper<ProcessBatchResponse>
 	Query: ResolverTypeWrapper<{}>
 	SetVariablesArgs: SetVariablesArgs
 	SetVariablesMode: SetVariablesMode
 	SetVariablesResponse: ResolverTypeWrapper<SetVariablesResponse>
-	String: ResolverTypeWrapper<Scalars['String']>
-	Uuid: ResolverTypeWrapper<Scalars['Uuid']>
+	String: ResolverTypeWrapper<Scalars['String']['output']>
+	Uuid: ResolverTypeWrapper<Scalars['Uuid']['output']>
 	Variable: ResolverTypeWrapper<Variable>
 	VariableInput: VariableInput
 }
 
 /** Mapping between all available schema types and the resolvers parents */
 export type ResolversParentTypes = {
-	Boolean: Scalars['Boolean']
-	DateTime: Scalars['DateTime']
+	Boolean: Scalars['Boolean']['output']
+	DateTime: Scalars['DateTime']['output']
 	Event: Event
 	EventArgs: EventArgs
-	Int: Scalars['Int']
-	Json: Scalars['Json']
+	Int: Scalars['Int']['output']
+	Json: Scalars['Json']['output']
 	Mutation: {}
 	ProcessBatchResponse: ProcessBatchResponse
 	Query: {}
 	SetVariablesArgs: SetVariablesArgs
 	SetVariablesResponse: SetVariablesResponse
-	String: Scalars['String']
-	Uuid: Scalars['Uuid']
+	String: Scalars['String']['output']
+	Uuid: Scalars['Uuid']['output']
 	Variable: Variable
 	VariableInput: VariableInput
 }

package/src/triggers/TriggerHandler.ts

@@ -72,7 +72,7 @@ export class TriggerHandler {
 	private async directUpdateHandler(event: AfterUpdateEvent) {
 		const updateListeners = this.listenersStore.getUpdateListeners(event.entity.name)
 		updateListeners.map(listener => {
-			if (event.data.some(it => listener.fields.has(it.fieldName))) {
+			if (event.data.some(it => listener.fields.has(it.fieldName) && it.value !== it.old)) {
 				this.payloadManager.add({
 					listener,
 					entity: event.entity,
@@ -119,7 +119,7 @@ export class TriggerHandler {
 	private async indirectChangesUpdatesHandlerInner(event: AfterUpdateEvent | BeforeUpdateEvent, type: 'fields' | 'relations') {
 		const indirectEntityListeners = this.listenersStore.getIndirectListeners(event.entity.name)
 		const promises = indirectEntityListeners.map(listener => {
-			if (event.data.some(val => listener[type].has(val.fieldName))) {
+			if (event.data.some(val => listener[type].has(val.fieldName) && (!('old' in val) || val.value !== val.old))) {
 				return this.collectDeepChanges(event, listener, {
 					[event.entity.primary]: { eq: event.id },
 				})

package/src/triggers/TriggerPayloadBuilder.ts

@@ -23,7 +23,7 @@ export class TriggerPayloadBuilder {
 		const selections = await this.fetchSelection(filteredEvents)
 		const triggerType = filteredEvents[0].listener.trigger.type
 		if (triggerType === 'basic') {
-			return filteredEvents.map(it => ({ trigger: it.listener.trigger.name, ...this.buildBaseEventPayloads(it, selections[it.primary]) }))
+			return filteredEvents.map(it => ({ trigger: it.listener.trigger.name, ...this.buildBaseEventPayloads(it, it.selection ?? selections[it.primary]) }))
 		}
 		if (triggerType === 'watch') {
 			return this.buildWatchEventPayloads(filteredEvents, selections)
@@ -56,7 +56,7 @@ export class TriggerPayloadBuilder {
 				trigger: events[0].listener.trigger.name,
 				entity: events[0].entity.name,
 				id: eventsByPrimary.primary,
-				selection: events[0].selection ?? selections[eventsByPrimary.primary],
+				selection: eventsByPrimary.events[0].selection ?? selections[eventsByPrimary.primary],
 				events: eventsByPrimary.events.map(it => this.buildBaseEventPayloads(it)),
 			})
 		}
@@ -71,7 +71,7 @@ export class TriggerPayloadBuilder {
 					entity: event.cause.entity.name,
 					id: event.cause.id,
 					selection,
-					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.resolvedValue])),
+					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
 				}
 			case 'AfterUpdateEvent':
@@ -85,7 +85,7 @@ export class TriggerPayloadBuilder {
 					entity: event.cause.entity.name,
 					id: event.cause.id,
 					selection,
-					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.resolvedValue])),
+					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
 					old: Object.fromEntries(afterEvent.data.map(it => [it.fieldName, it.old])),
 				}

package/src/triggers/TriggerPayloadPersister.ts

@@ -17,12 +17,15 @@ export class TriggerPayloadPersister {
 		private readonly providers: { uuid: () => string },
 		private readonly projectSlug: string,
 		private readonly stageId: string,
-		private readonly schemaId: number,
+		private readonly schemaId?: number,
 	) {
 	}
 
 	public async persist(trigger: Actions.AnyTrigger, payloads: ActionsPayload.AnyEventPayload[]): Promise<void> {
 		const chunkSize = 100
+		if (!this.schemaId) {
+			throw new Error('Schema id is not set')
+		}
 		for (let i = 0; i < payloads.length; i += chunkSize) {
 			const chunk = payloads.slice(i, i + chunkSize)
 			await InsertBuilder.create()
@@ -35,7 +38,7 @@ export class TriggerPayloadPersister {
 					num_retries: 0,
 					state: 'created',
 					stage_id: this.stageId,
-					schema_id: this.schemaId,
+					schema_id: this.schemaId!,
 					target: trigger.target,
 					trigger: trigger.name,
 					priority: trigger.priority ?? 0,

package/tests/cases/unit/generator.test.ts

@@ -1,9 +1,13 @@
 import { TriggerListenerBuilder, TriggerListeners } from '../../../src/triggers'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 import { Actions, Model } from '@contember/schema'
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 
 
+const assert = {
+	equal: (a: any, b: any) => expect(a).toEqual(b),
+	deepStrictEqual: (a: any, b: any) => expect(a).toStrictEqual(b),
+}
 const createTrigger = (watchNode: Actions.SelectionNode): Actions.AnyTrigger => ({
 	type: 'watch',
 	entity: 'Author',

package/tests/cases/unit/webhookHandler.test.ts

@@ -1,4 +1,4 @@
-import { assert, describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'bun:test'
 import { WebhookTargetHandler } from '../../../src/dispatch/WebhookTargetHandler'
 import { FetcherResponse } from '../../../src/dispatch/WebhookFetcher'
 import { createLogger, Logger, TestLoggerHandler } from '@contember/logger'
@@ -8,6 +8,10 @@ import { HandledEvent } from '../../../src/dispatch/types'
 import { testUuid } from '../../src/uuid'
 
 
+const assert = {
+	equal: (a: any, b: any) => expect(a).toEqual(b),
+	deepStrictEqual: (a: any, b: any) => expect(a).toStrictEqual(b),
+}
 const now = new Date('2024-06-20T12:00:00Z')
 const createTestEvent = (i = 0, row: Partial<EventRow> = {}): EventRow => ({
 	created_at: now,

package/tsconfig.settings.json

@@ -2,7 +2,6 @@
 	"extends": "../../tsconfig.settings.json",
 	"compilerOptions": {
 		"esModuleInterop": true,
-		"typeRoots": ["node_modules/@types", "./types"],
 		"experimentalDecorators": true
 	}
 }