@contember/engine-content-api 1.2.1 → 1.3.0-alpha.13

package/src/mapper/Mapper.ts

@@ -1,35 +1,44 @@
 import { Input, Model } from '@contember/schema'
-import { getColumnName } from '@contember/schema-utils'
-import { SelectGroupedObjects, SelectHydrator, SelectIndexedResultObjects, SelectResultObject } from './select'
-import { PathFactory } from './select'
-import * as database from '@contember/database'
-import { Client, SelectBuilder } from '@contember/database'
-import { SelectBuilderFactory } from './select'
+import { acceptFieldVisitor, getColumnName, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import {
+	OrderByHelper,
+	PathFactory,
+	SelectBuilderFactory,
+	SelectGroupedObjects,
+	SelectHydrator,
+	SelectIndexedResultObjects,
+	SelectResultObject,
+	WhereBuilder,
+} from './select'
+import { Client, Connection, ConstraintHelper, SelectBuilder } from '@contember/database'
 import { PredicatesInjector } from '../acl'
-import { WhereBuilder } from './select'
 import { JunctionTableManager } from './JunctionTableManager'
 import { DeletedEntitiesStorage, DeleteExecutor } from './delete'
 import { MutationEntryNotFoundError, MutationResultList } from './Result'
-import { Updater } from './update'
-import { Inserter } from './insert'
+import { UpdateBuilder, Updater } from './update'
+import { InsertBuilder, Inserter } from './insert'
 import { tryMutation } from './ErrorUtils'
-import { OrderByHelper } from './select'
-import {  ObjectNode, UniqueWhereExpander } from '../inputProcessing'
-import { UpdateBuilder } from './update'
+import { ObjectNode, UniqueWhereExpander } from '../inputProcessing'
 import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
-import { ConstraintHelper } from '@contember/database'
 import { ImplementationException } from '../exception'
+import { EventManager } from './EventManager'
 
-export class Mapper {
+export class Mapper<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
 	private primaryKeyCache: Record<string, Promise<string> | string> = {}
+	private systemVariablesSetupDone: Promise<void> | undefined
 	public readonly deletedEntities = new DeletedEntitiesStorage()
 	public readonly mutex = new Mutex()
 	public readonly constraintHelper: ConstraintHelper
 
+	public readonly eventManager: EventManager
+
 	constructor(
+		public readonly db: Client<ConnectionType>,
+		public readonly identityId: string,
+		public readonly transactionId: string,
 		private readonly schema: Model.Schema,
-		public readonly db: database.Client,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -41,9 +50,10 @@ export class Mapper {
 		private readonly pathFactory: PathFactory,
 	) {
 		this.constraintHelper = new ConstraintHelper(db)
+		this.eventManager = new EventManager(this)
 	}
 
-	public async selectField(entity: Model.Entity, where: Input.UniqueWhere, fieldName: string) {
+	public async selectField(entity: Model.Entity, where: Input.UniqueWhere | CheckedPrimary, fieldName: string) {
 		const columnName = getColumnName(this.schema, entity, fieldName)
 
 		const qb = SelectBuilder.create() //
@@ -119,7 +129,7 @@ export class Mapper {
 		relationPath: Model.AnyRelationContext[],
 		groupBy?: string,
 	) {
-		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
+		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, undefined)
 		const path = this.pathFactory.create([])
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
@@ -163,15 +173,17 @@ export class Mapper {
 		return Object.fromEntries(result)
 	}
 
-	public async insert(entity: Model.Entity, data: Input.CreateDataInput): Promise<MutationResultList> {
+	public async insert(
+		entity: Model.Entity,
+		data: Input.CreateDataInput,
+		builderCb: (builder: InsertBuilder) => void = () => {},
+	): Promise<MutationResultList> {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, () =>
-			this.inserter.insert(this, entity, data, id => {
-				const where = { [entity.primary]: id }
-				this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-			}),
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () =>
+			this.insertInternal(entity, data, builderCb),
 		)
 	}
 
@@ -184,7 +196,8 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, async () => {
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by)]
@@ -195,19 +208,21 @@ export class Mapper {
 
 	public async updateInternal(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		predicateFields: string[],
+		by: Input.UniqueWhere | CheckedPrimary,
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
-		return tryMutation(this.schema, async () => {
+		if (entity.view) {
+			throw new ImplementationException()
+		}
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by)]
+				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
 			}
-			return await this.updater.updateCb(this, entity, primaryValue, predicateFields, builderCb)
+			return await this.updater.updateCb(this, entity, primaryValue, builderCb)
 		})
 	}
-
 	public async upsert(
 		entity: Model.Entity,
 		by: Input.UniqueWhere,
@@ -218,18 +233,23 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, async () => {
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
-				return await this.inserter.insert(this, entity, create, id => {
-					const where = { [entity.primary]: id }
-					this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-				})
+				return await this.insertInternal(entity, create)
 			}
 			return await this.updater.update(this, entity, primaryValue, update, filter)
 		})
 	}
 
+	private insertInternal(entity: Model.Entity, data: Input.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
+		return this.inserter.insert(this, entity, data, id => {
+			const where = { [entity.primary]: id }
+			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
+		}, builderCb)
+	}
+
 	public async delete(
 		entity: Model.Entity,
 		by: Input.UniqueWhere | CheckedPrimary,
@@ -238,37 +258,60 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () => {
+			return this.deleteExecutor.execute(this, entity, by, filter)
+		})
 	}
 
 	public async connectJunction(
-		owningEntity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		owningPrimary: Input.PrimaryValue,
-		inversePrimary: Input.PrimaryValue,
+		entity: Model.Entity,
+		relation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
+		thisPrimary: Input.PrimaryValue,
+		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return await this.junctionTableManager.connectJunction(
-			this.db,
-			owningEntity,
-			relation,
-			owningPrimary,
-			inversePrimary,
-		)
+		await this.setupSystemVariables()
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.connectJunction(this, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.connectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
+			},
+			visitColumn: err,
+			visitOneHasMany: err,
+			visitOneHasOneInverse: err,
+			visitOneHasOneOwning: err,
+			visitManyHasOne: err,
+		})
 	}
 
 	public async disconnectJunction(
-		owningEntity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		owningPrimary: Input.PrimaryValue,
-		inversePrimary: Input.PrimaryValue,
+		entity: Model.Entity,
+		relation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
+		thisPrimary: Input.PrimaryValue,
+		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return await this.junctionTableManager.disconnectJunction(
-			this.db,
-			owningEntity,
-			relation,
-			owningPrimary,
-			inversePrimary,
-		)
+		await this.setupSystemVariables()
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.disconnectJunction(this, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.disconnectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
+			},
+			visitColumn: err,
+			visitOneHasMany: err,
+			visitOneHasOneInverse: err,
+			visitOneHasOneOwning: err,
+			visitManyHasOne: err,
+		})
 	}
 
 	public async getPrimaryValue(
@@ -295,6 +338,12 @@ export class Mapper {
 	private hashWhere(entityName: string, where: Input.UniqueWhere): string {
 		return JSON.stringify([entityName, where])
 	}
-}
 
-export type MapperFactory = (db: Client) => Mapper
+	private async setupSystemVariables() {
+		this.systemVariablesSetupDone ??= (async () => {
+			await this.db.query('SELECT set_config(?, ?, false)', ['tenant.identity_id', this.identityId]) // todo rename to system.identity_id
+			await this.db.query('SELECT set_config(?, ?, false)', ['system.transaction_id', this.transactionId])
+		})()
+		await this.systemVariablesSetupDone
+	}
+}

package/src/mapper/MapperFactory.ts

@@ -0,0 +1,69 @@
+import { PredicatesInjector } from '../acl'
+import { PathFactory, SelectBuilderFactory, WhereBuilder } from './select'
+import { UniqueWhereExpander } from '../inputProcessing'
+import { JunctionTableManager } from './JunctionTableManager'
+import { DeleteExecutor } from './delete'
+import { Updater } from './update'
+import { Inserter } from './insert'
+import { Model } from '@contember/schema'
+import { Client, Connection } from '@contember/database'
+import { Mapper } from './Mapper'
+import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+
+export type MapperFactoryHook = (mapper: Mapper) => void
+
+export class MapperFactory {
+
+	public readonly hooks: MapperFactoryHook[] = []
+
+	constructor(
+		private readonly db: Client,
+		private readonly identityId: string,
+		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly predicatesInjector: PredicatesInjector,
+		private readonly selectBuilderFactory: SelectBuilderFactory,
+		private readonly uniqueWhereExpander: UniqueWhereExpander,
+		private readonly whereBuilder: WhereBuilder,
+		private readonly junctionTableManager: JunctionTableManager,
+		private readonly deleteExecutor: DeleteExecutor,
+		private readonly updater: Updater,
+		private readonly inserter: Inserter,
+		private readonly pathFactory: PathFactory,
+		private readonly providers: Providers,
+	) {
+	}
+
+	public create() {
+		return this.createInternal(this.db)
+	}
+
+	public transaction<T>(cb: (mapper: Mapper<Connection.TransactionLike>) => Promise<T>): Promise<T> {
+		return this.db.transaction(async trx => {
+			await trx.connection.query(Connection.REPEATABLE_READ)
+			const mapper = this.createInternal(trx)
+			return await cb(mapper)
+		})
+	}
+
+	private createInternal<T extends Connection.ConnectionLike>(db: Client<T>) {
+		const mapper = new Mapper<T>(
+			db,
+			this.identityId,
+			this.providers.uuid(),
+			this.schema,
+			this.schemaDatabaseMetadata,
+			this.predicatesInjector,
+			this.selectBuilderFactory,
+			this.uniqueWhereExpander,
+			this.whereBuilder,
+			this.junctionTableManager,
+			this.deleteExecutor,
+			this.updater,
+			this.inserter,
+			this.pathFactory,
+		)
+		this.hooks.forEach(it => it(mapper))
+		return mapper
+	}
+}

package/src/mapper/Result.ts

@@ -3,6 +3,7 @@ import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
 import { SerializationFailureError } from '@contember/database'
 import { logger } from '@contember/logger'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -50,7 +51,7 @@ interface MutationResultInterface {
 	hints: MutationResultHint[]
 }
 
-export type RowValues = { [fieldName: string]: Value.AtomicValue }
+export type RowValues = { [fieldName: string]: Value.FieldValue }
 
 export class MutationUpdateOk implements MutationResultInterface {
 	result = MutationResultType.ok as const
@@ -63,6 +64,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly primary: Value.PrimaryValue,
 		public readonly input: Input.UpdateDataInput,
 		public readonly values: RowValues,
+		public readonly oldValues?: RowValues,
 	) {}
 }
 
@@ -170,7 +172,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 	hints: MutationResultHint[] = []
 	message: string
 
-	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere) {
+	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.Where) {
 		this.message = 'for input ' + JSON.stringify(where)
 	}
 }
@@ -211,6 +213,7 @@ export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
 	schema: Model.Schema,
+	schemaDatabaseMetadata: SchemaDatabaseMetadata,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {
@@ -219,7 +222,7 @@ export const collectResults = async (
 		.filter((it): it is Promise<ResultListNotFlatten> => !!it)
 		.map(it =>
 			it //
-				.catch(e => [convertError(schema, e)])
+				.catch(e => [convertError(schema, schemaDatabaseMetadata, e)])
 				.then(value => ({ value, index: index++ })),
 		)
 	const results = await Promise.allSettled(allPromises)