@contember/engine-system-api 2.1.0-alpha.9 → 2.1.0-beta.1

package/src/migrations/runner.ts

@@ -66,7 +66,6 @@ const migrations = {
 	'2025-03-14-110000-fix-missing-index': _20250314110000fixmissingindex,
 }
 
-
 export class SystemMigrationsRunner {
 	constructor(
 		private readonly databaseContextFactory: DatabaseContextFactory,
@@ -86,16 +85,18 @@ export class SystemMigrationsRunner {
 			}
 			const migrationResolver = new GroupMigrationsResolver(
 				new SnapshotMigrationResolver(snapshot, migrations),
-				Object.fromEntries(Object.entries(this.migrationGroups).map(
-					([group, it]) => [
-						group,
-						new SnapshotMigrationResolver(
-							it.snapshot,
-							it.migrations,
-							group.replace(/[^-_\w]+/g, '-'),
-							migrations,
-						),
-					]),
+				Object.fromEntries(
+					Object.entries(this.migrationGroups).map(
+						([group, it]) => [
+							group,
+							new SnapshotMigrationResolver(
+								it.snapshot,
+								it.migrations,
+								group.replace(/[^-_\w]+/g, '-'),
+								migrations,
+							),
+						],
+					),
 				),
 			)
 			const migrationsRunner = new DbMigrationsRunner(connection, this.project.systemSchema, migrationResolver)
@@ -106,7 +107,6 @@ export class SystemMigrationsRunner {
 					const dbContextMigrations = this.databaseContextFactory.create(connection)
 					return this.databaseMetadataResolver.resolveMetadata(dbContextMigrations.client, schema)
 				},
-
 			})
 		})
 		await singleConnection.end()

package/src/migrations/snapshot-factory.ts

@@ -40,6 +40,5 @@ $$
 		EXECUTE FORMAT('ALTER FUNCTION trigger_event() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
 	END
 $$`)
-
 	}
 }

package/src/model/ProjectInitializer.ts

@@ -14,20 +14,25 @@ export class ProjectInitializer {
 	) {}
 
 	public async initialize(logger: Logger) {
-		return await logger.scope(async initLogger => {
-			initLogger.debug('Executing system schema migrations')
-			await this.migrationsRunner.run(initLogger)
-			const dbContext = this.databaseContext
-			await retryTransaction(
-				() => dbContext.transaction(async trx => {
-					await this.initStages(trx, logger)
-				}),
-				message => initLogger.warn(message),
-			)
-			if (dbContext.client.connection instanceof Connection) {
-				await dbContext.client.connection.clearPool()
-			}
-		}, {}, { handler: FingerCrossedLoggerHandler.factory() })
+		return await logger.scope(
+			async initLogger => {
+				initLogger.debug('Executing system schema migrations')
+				await this.migrationsRunner.run(initLogger)
+				const dbContext = this.databaseContext
+				await retryTransaction(
+					() =>
+						dbContext.transaction(async trx => {
+							await this.initStages(trx, logger)
+						}),
+					message => initLogger.warn(message),
+				)
+				if (dbContext.client.connection instanceof Connection) {
+					await dbContext.client.connection.clearPool()
+				}
+			},
+			{},
+			{ handler: FingerCrossedLoggerHandler.factory() },
+		)
 	}
 
 	private async initStages(db: DatabaseContext<Connection.TransactionLike>, logger: Logger) {

package/src/model/commands/Command.ts

@@ -13,4 +13,4 @@ namespace Command {
 		bus: CommandBus
 	}
 }
-export { type Command }
+export type { Command }

package/src/model/commands/CommandBus.ts

@@ -12,8 +12,6 @@ export class CommandBus<ConnectionType extends Connection.ConnectionLike = Conne
 	async transaction<T>(
 		transactionScope: (wrapper: CommandBus<Connection.TransactionLike>) => Promise<T> | T,
 	): Promise<T> {
-		return await this.client.transaction(client =>
-			transactionScope(new CommandBus<Connection.TransactionLike>(client, this.providers)),
-		)
+		return await this.client.transaction(client => transactionScope(new CommandBus<Connection.TransactionLike>(client, this.providers)))
 	}
 }

package/src/model/commands/migrations/SaveMigrationCommand.ts

@@ -25,8 +25,7 @@ export class SaveMigrationCommand implements Command<number> {
 		const latestId = (await SelectBuilder.create<{ id: number }>()
 			.from('schema_migration')
 			.select(new Literal('max(id)'), 'id')
-			.getResult(db)
-		)[0]?.id ?? 0
+			.getResult(db))[0]?.id ?? 0
 
 		const newId = latestId + 1
 		const result = await InsertBuilder.create()

package/src/model/database/DatabaseContext.ts

@@ -35,8 +35,7 @@ const createDatabaseContext = <ConnectionType extends Connection.ConnectionLike
 			await client.query(Connection.REPEATABLE_READ)
 			return cb(createDatabaseContext(client, providers))
 		}),
-	scope: cb =>
-		client.scope(client => cb(createDatabaseContext(client, providers))),
+	scope: cb => client.scope(client => cb(createDatabaseContext(client, providers))),
 	commandBus: new CommandBus(client, providers),
 	locked: (lock, cb) => client.locked(lock, client => cb(createDatabaseContext(client, providers))),
 })

package/src/model/dtos/ExecutedMigration.ts

@@ -11,7 +11,6 @@ export class ExecutedMigration implements Migration {
 		public readonly executedAt: Date,
 		public readonly checksum: string | null,
 		public readonly type: 'schema' | 'content',
-
 	) {
 		this.version = MigrationVersionHelper.extractVersion(name)
 	}

package/src/model/dtos/Stage.ts

@@ -4,4 +4,3 @@ export interface Stage {
 	readonly slug: string
 	readonly schema: string
 }
-

package/src/model/events/types.ts

@@ -60,4 +60,3 @@ export class DeleteEvent implements Event {
 	) {
 	}
 }
-

package/src/model/metadata/SchemaDatabaseMetadataResolverStore.ts

@@ -2,7 +2,6 @@ import { DatabaseContext } from '../database'
 import { DatabaseMetadata, DatabaseMetadataResolver } from '@contember/database'
 
 export class SchemaDatabaseMetadataResolverStore {
-
 	private cache: Map<string, DatabaseMetadata> = new Map()
 
 	constructor(
@@ -27,7 +26,6 @@ export class SchemaDatabaseMetadataResolverStore {
 	}
 }
 
-
 export class MigrationsDatabaseMetadataResolverStoreFactory {
 	constructor(
 		private resolver: DatabaseMetadataResolver,

package/src/model/migrations/ProjectMigrator.ts

@@ -15,6 +15,11 @@ import { SchemaProvider } from './SchemaProvider'
 import { SaveSchemaCommand } from '../commands/schema/SaveSchemaCommand'
 import { ImplementationException } from '../../utils'
 
+type MigrationVariables = {
+	system_schema: string
+	project_slug: string
+}
+
 export class ProjectMigrator {
 	constructor(
 		private readonly migrationDescriber: MigrationDescriber,
@@ -52,19 +57,18 @@ export class ProjectMigrator {
 		const metadataStore = this.migrationsDatabaseMetadataResolverStoreFactory.create(db)
 
 		for (const migration of sorted) {
-
 			if (migration.type === 'schema') {
 				const formatVersion = migration.formatVersion
 
 				for (const modification of migration.modifications) {
-					[schema] = await this.applyModification(
+					;[schema] = await this.applyModification(
 						db.client,
 						stages,
 						schema,
 						modification,
 						formatVersion,
 						migration.version,
-						db.client.schema,
+						project,
 						metadataStore,
 					)
 				}
@@ -88,7 +92,6 @@ export class ProjectMigrator {
 				// event log uses deferred constraint triggers, we need to fire them before ALTER
 				await db.client.query(`SET CONSTRAINTS ALL IMMEDIATE`)
 				await db.client.query(`SET CONSTRAINTS ALL DEFERRED`)
-
 			}
 			id = await db.commandBus.execute(new SaveMigrationCommand(migration))
 		}
@@ -96,15 +99,17 @@ export class ProjectMigrator {
 			throw new ImplementationException()
 		}
 
-		await db.commandBus.execute(new SaveSchemaCommand({
-			schema,
-			meta: {
-				id,
-				updatedAt: new Date(),
-				version: sorted[sorted.length - 1].version,
-				checksum: calculateSchemaChecksum(schema),
-			},
-		}))
+		await db.commandBus.execute(
+			new SaveSchemaCommand({
+				schema,
+				meta: {
+					id,
+					updatedAt: new Date(),
+					version: sorted[sorted.length - 1].version,
+					checksum: calculateSchemaChecksum(schema),
+				},
+			}),
+		)
 	}
 
 	private async executeContentMigration({ query, stages, version, ...ctx }: {
@@ -180,8 +185,8 @@ export class ProjectMigrator {
 				if (errors.length > 0) {
 					throw new InvalidSchemaError(
 						migration.version,
-						'Migration generates invalid schema: \n' +
-						errors.map(it => `${it.path.join('.')}: [${it.code}] ${it.message}`).join('\n'),
+						'Migration generates invalid schema: \n'
+							+ errors.map(it => `${it.path.join('.')}: [${it.code}] ${it.message}`).join('\n'),
 					)
 				}
 			}
@@ -193,13 +198,20 @@ export class ProjectMigrator {
 		if (errors.length > 0) {
 			throw new InvalidSchemaError(
 				toExecute[toExecute.length - 1].version,
-				'Migration generates invalid schema: \n' +
-				errors.map(it => it.path.join('.') + ': ' + it.message).join('\n'),
+				'Migration generates invalid schema: \n'
+					+ errors.map(it => it.path.join('.') + ': ' + it.message).join('\n'),
 			)
 		}
 		return toExecute
 	}
 
+	private sqlPreprocessor(text: string, variables: MigrationVariables): string {
+		return Object.entries(variables).reduce(
+			(content, [key, value]) => content.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value),
+			text,
+		)
+	}
+
 	private async applyModification(
 		db: Client,
 		stages: Stage[],
@@ -207,7 +219,7 @@ export class ProjectMigrator {
 		modification: Migration.Modification,
 		formatVersion: number,
 		migrationVersion: string,
-		systemSchema: string,
+		project: { slug: string; systemSchema: string },
 		metadataStore: SchemaDatabaseMetadataResolverStore,
 	): Promise<[Schema]> {
 		const {
@@ -217,11 +229,15 @@ export class ProjectMigrator {
 		for (const stage of stages) {
 			const databaseMetadata = await metadataStore.getMetadata(stage.schema)
 			const sql = getSql({
-				systemSchema,
+				systemSchema: project.systemSchema,
 				databaseMetadata,
 				invalidateDatabaseMetadata: () => metadataStore.invalidate(stage.schema),
 			})
-			await this.executeOnStage(db, stage, sql, migrationVersion)
+			const processedSql = this.sqlPreprocessor(sql, {
+				project_slug: project.slug,
+				system_schema: project.systemSchema,
+			})
+			await this.executeOnStage(db, stage, processedSql, migrationVersion)
 		}
 		return [newSchema]
 	}

package/src/model/migrations/SchemaProvider.ts

@@ -30,15 +30,14 @@ export class SchemaProvider {
 	}
 
 	async buildSchemaFromMigrations(db: DatabaseContext): Promise<SchemaWithMeta> {
-		const newMigrations = (await this.executedMigrationsResolver.getMigrations(db))
+		const newMigrations = await this.executedMigrationsResolver.getMigrations(db)
 
 		const partialResult = newMigrations.reduce<SchemaWithMeta>(
 			(schema, migration) => {
-				if (migration.type !== 'schema') {
-					return schema
-				}
 				return {
-					schema: this.schemaMigrator.applyModifications(schema.schema, migration.modifications, migration.formatVersion),
+					schema: migration.type !== 'schema'
+						? schema.schema
+						: this.schemaMigrator.applyModifications(schema.schema, migration.modifications, migration.formatVersion),
 					meta: {
 						version: migration.version,
 						id: migration.id,
@@ -63,7 +62,7 @@ export class SchemaProvider {
 		}
 	}
 
-	public async fetch({ db, currentSchema  }: {
+	public async fetch({ db, currentSchema }: {
 		db: DatabaseContext
 		currentSchema?: SchemaWithMeta | null
 	}): Promise<SchemaWithMeta> {

package/src/model/queries/events/EventsQuery.ts

@@ -5,7 +5,8 @@ import {
 	Literal,
 	Operator,
 	SelectBuilder,
-	SelectBuilderSpecification, Value,
+	SelectBuilderSpecification,
+	Value,
 } from '@contember/database'
 import { ContentEvent } from '../../events'
 import { EventsFilter, EventsFilterDate, EventsOrder } from '../../../schema'
@@ -52,11 +53,8 @@ export class EventsQuery extends DatabaseQuery<ContentEvent[]> {
 			.select('applied_at')
 			.select('identity_id')
 			.select(['event_data', 'transaction_id'])
-
 			.from('event_data')
-			.join('stage_transaction', undefined, on =>
-				on.columnsEq(['event_data', 'transaction_id'], ['stage_transaction', 'transaction_id']),
-			)
+			.join('stage_transaction', undefined, on => on.columnsEq(['event_data', 'transaction_id'], ['stage_transaction', 'transaction_id']))
 			.match(qb => {
 				switch (this.order) {
 					case EventsOrder.AppliedAtAsc:
@@ -94,10 +92,8 @@ export class EventsQuery extends DatabaseQuery<ContentEvent[]> {
 
 				return qb.where(ConditionBuilder.create().or(ConditionBuilder.create(ors)))
 			})
-
 			.limit(this.limit, this.offset)
 
 		return createEventsFromRows(await qb.getResult(db))
 	}
-
 }

package/src/model/queries/events/OldValuesQuery.ts

@@ -10,10 +10,10 @@ export class OldValuesQuery extends DatabaseQuery<Record<string, any>> {
 			.select(expr => expr.raw('JSONB_OBJECT_AGG(values.key, values.value ORDER BY previous.created_at ASC)'), 'values')
 			.select(['event_data', 'id'])
 			.from('event_data')
-			.join('event_data', 'previous', on => on
-				.columnsEq(['event_data', 'row_ids'], ['previous', 'row_ids'])
-				.compareColumns(['event_data', 'created_at'], Operator.gt, ['previous', 'created_at']),
-			)
+			.join('event_data', 'previous', on =>
+				on
+					.columnsEq(['event_data', 'row_ids'], ['previous', 'row_ids'])
+					.compareColumns(['event_data', 'created_at'], Operator.gt, ['previous', 'created_at']))
 			.join(new Literal('JSONB_EACH(previous.values)'), 'values')
 			.where(where => where.in(['event_data', 'id'], this.ids))
 			.groupBy(['event_data', 'id'])

package/src/model/queries/schema/SchemaQuery.ts

@@ -3,14 +3,12 @@ import { Schema } from '@contember/schema'
 import { SchemaWithMeta } from '../../migrations'
 
 export class SchemaQuery extends DatabaseQuery<SchemaWithMeta | null> {
-
 	constructor(
 		private readonly currentHash?: string,
 	) {
 		super()
 	}
 
-
 	async fetch(queryable: DatabaseQueryable): Promise<SchemaWithMeta | null> {
 		const query = SelectBuilder.create<{
 			schema: Schema
@@ -31,7 +29,7 @@ export class SchemaQuery extends DatabaseQuery<SchemaWithMeta | null> {
 				return it.where(it => it.raw('checksum != ?', this.currentHash))
 			})
 
-		const row =  this.fetchOneOrNull(await query.getResult(queryable.db))
+		const row = this.fetchOneOrNull(await query.getResult(queryable.db))
 		if (!row) {
 			return null
 		}

package/src/model/stages/StageCreator.ts

@@ -4,8 +4,6 @@ import { StageConfig } from '../../types'
 import { DatabaseContext } from '../database'
 
 class StageCreator {
-	constructor() {}
-
 	public async createStage(
 		db: DatabaseContext,
 		stage: StageConfig,

package/src/resolvers/ResolverFactory.ts

@@ -2,7 +2,7 @@ import { EventsQueryResolver, ExecutedMigrationsQueryResolver, StagesQueryResolv
 import { Event, EventType, Resolvers } from '../schema'
 import { assertNever } from '../utils'
 import { MigrateMutationResolver, MigrationAlterMutationResolver, TruncateMutationResolver } from './mutation'
-import { DateTimeType, JSONType, createJsonLikeType } from '@contember/graphql-utils'
+import { createJsonLikeType, DateTimeType, JSONType } from '@contember/graphql-utils'
 import { EventOldValuesResolver } from './types'
 import { GraphQLError, GraphQLScalarType, Kind } from 'graphql'
 import { SchemaQueryResolver } from './query/SchemaQueryResolver'
@@ -68,8 +68,8 @@ export class ResolverFactory {
 	}
 }
 
-const parseValue = (value: any)  => {
-	if ((typeof value === 'string' && value !== '') || typeof value === 'number' && isFinite(value) && Math.floor(value) === value) {
+const parseValue = (value: any) => {
+	if ((typeof value === 'string' && value !== '') || typeof value === 'number' && Number.isFinite(value) && Math.floor(value) === value) {
 		return value
 	}
 	throw new GraphQLError('PrimaryKey cannot represent value: ' + JSON.stringify(value))
@@ -77,7 +77,6 @@ const parseValue = (value: any)  => {
 
 const SchemaType = createJsonLikeType('Schema', 'Content schema custom scalar type')
 
-
 export const PrimaryKeyType = new GraphQLScalarType({
 	name: 'PrimaryKey',
 	description: 'PrimaryKey custom scalar type. Can be Int or String',

package/src/resolvers/SystemResolverContext.ts

@@ -12,7 +12,9 @@ export class SystemResolverContextFactory {
 		private readonly authorizator: Authorizator<Identity>,
 	) {}
 
-	public async create({ getSchema, identity, project, db }: Pick<SystemResolverContext, 'getSchema' | 'db' | 'identity' | 'project'>): Promise<SystemResolverContext> {
+	public async create(
+		{ getSchema, identity, project, db }: Pick<SystemResolverContext, 'getSchema' | 'db' | 'identity' | 'project'>,
+	): Promise<SystemResolverContext> {
 		const stagePermissionsFactory = new StagePermissionsFactory(getSchema)
 		const loaders = new Map<LoaderFactory<any, any>, ItemLoader<any, any>>()
 		return {

package/src/resolvers/mutation/MigrateMutationResolver.ts

@@ -32,45 +32,46 @@ export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 	): Promise<MigrateResponse> {
 		const migrations = this.parseMigrationInput(args)
 
-		return context.db.locked(pg_lock_id, db => db.transaction(async trx => {
-			const stages = await trx.queryHandler.fetch(new StagesQuery())
-			for (const stage of stages) {
-				await context.requireAccess(AuthorizationActions.PROJECT_MIGRATE, stage.slug)
-			}
-			try {
-				await this.projectMigrator.migrate({
-					db: trx,
-					project: context.project,
-					identity: context.identity,
-					stages,
-					migrationsToExecute: migrations,
-					options: {
-						ignoreOrder: force,
-						skipExecuted: true,
-					},
-				})
-			} catch (e) {
-				if (e instanceof MigrationError) {
-					await trx.client.connection.rollback()
-					const error = {
-						code: e.code,
-						migration: e.version,
-						developerMessage: e.message,
-					}
-					return {
-						ok: false,
-						errors: [error],
-						error,
+		return context.db.locked(pg_lock_id, db =>
+			db.transaction(async trx => {
+				const stages = await trx.queryHandler.fetch(new StagesQuery())
+				for (const stage of stages) {
+					await context.requireAccess(AuthorizationActions.PROJECT_MIGRATE, stage.slug)
+				}
+				try {
+					await this.projectMigrator.migrate({
+						db: trx,
+						project: context.project,
+						identity: context.identity,
+						stages,
+						migrationsToExecute: migrations,
+						options: {
+							ignoreOrder: force,
+							skipExecuted: true,
+						},
+					})
+				} catch (e) {
+					if (e instanceof MigrationError) {
+						await trx.client.connection.rollback()
+						const error = {
+							code: e.code,
+							migration: e.version,
+							developerMessage: e.message,
+						}
+						return {
+							ok: false,
+							errors: [error],
+							error,
+						}
+					} else {
+						throw e
 					}
-				} else {
-					throw e
 				}
-			}
-			return {
-				ok: true,
-				errors: [],
-			}
-		}))
+				return {
+					ok: true,
+					errors: [],
+				}
+			}))
 	}
 
 	private parseMigrationInput(args: MutationMigrateArgs): MigrationInput[] {

package/src/resolvers/mutation/MigrationAlterMutationResolver.ts

@@ -13,7 +13,6 @@ import { DeleteMigrationErrorCode, MigrationAlterer, UpdateMigrationErrorCode }
 import { Migration } from '@contember/schema-migrations'
 
 export class MigrationAlterMutationResolver implements MutationResolver<'migrationModify'>, MutationResolver<'migrationDelete'> {
-
 	constructor(private readonly migrationAlterer: MigrationAlterer) {}
 
 	async migrationModify(

package/src/resolvers/query/EventsQueryResolver.ts

@@ -29,12 +29,14 @@ export class EventsQueryResolver implements QueryResolver<'events'> {
 				'You are not allowed to view a history.',
 			)
 
-			const history = await db.queryHandler.fetch(new EventsQuery(
-				args?.filter ?? {},
-				args?.order ?? EventsOrder.AppliedAtDesc,
-				args?.offset ?? 0,
-				Math.min(args?.limit ?? 1000, 10000),
-			))
+			const history = await db.queryHandler.fetch(
+				new EventsQuery(
+					args?.filter ?? {},
+					args?.order ?? EventsOrder.AppliedAtDesc,
+					args?.offset ?? 0,
+					Math.min(args?.limit ?? 1000, 10000),
+				),
+			)
 
 			return await this.eventResponseBuilder.buildResponse(history)
 		})