@contember/engine-system-api 1.1.2 → 1.2.0-alpha.11

package/graphql.codegen.yml

@@ -15,8 +15,6 @@ generates:
       - "typescript"
       - "typescript-operations"
       - "typescript-resolvers"
-require:
-  - "ts-node/register"
 hooks:
   afterAllFileWrite:
     - eslint --fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.1.2",
+  "version": "1.2.0-alpha.11",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,28 +9,28 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@contember/authorization": "^1.1.2",
-    "@contember/database": "^1.1.2",
-    "@contember/database-migrations": "^1.1.2",
-    "@contember/dic": "^1.1.2",
-    "@contember/engine-common": "^1.1.2",
-    "@contember/graphql-utils": "^1.1.2",
-    "@contember/queryable": "^1.1.2",
-    "@contember/schema": "^1.1.2",
-    "@contember/schema-migrations": "^1.1.2",
-    "@contember/schema-utils": "^1.1.2",
-    "@graphql-tools/utils": "^7.10.0",
+    "@contember/authorization": "^1.2.0-alpha.11",
+    "@contember/database": "^1.2.0-alpha.11",
+    "@contember/database-migrations": "^1.2.0-alpha.11",
+    "@contember/dic": "^1.2.0-alpha.11",
+    "@contember/engine-common": "^1.2.0-alpha.11",
+    "@contember/graphql-utils": "^1.2.0-alpha.11",
+    "@contember/queryable": "^1.2.0-alpha.11",
+    "@contember/schema": "^1.2.0-alpha.11",
+    "@contember/schema-migrations": "^1.2.0-alpha.11",
+    "@contember/schema-utils": "^1.2.0-alpha.11",
+    "@graphql-tools/utils": "^8.6.13",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^1.1.2",
-    "@contember/schema-definition": "^1.1.2",
-    "@graphql-codegen/cli": "^1.15.2",
-    "@graphql-codegen/typescript": "^1.15.2",
-    "@graphql-codegen/typescript-operations": "^1.15.2",
-    "@graphql-codegen/typescript-resolvers": "^1.15.2",
-    "@types/node": "^17.0.5",
-    "graphql": "^15.4.0",
+    "@contember/engine-api-tester": "^1.2.0-alpha.11",
+    "@contember/schema-definition": "^1.2.0-alpha.11",
+    "@graphql-codegen/cli": "^2.6.2",
+    "@graphql-codegen/typescript": "^2.5.1",
+    "@graphql-codegen/typescript-operations": "^2.4.2",
+    "@graphql-codegen/typescript-resolvers": "^2.6.6",
+    "@types/node": "^18",
+    "graphql": "^16.5.0",
     "pg": "^8.5.0"
   },
   "peerDependencies": {

package/src/index.ts

@@ -3,21 +3,22 @@ export { SchemaMigrator, MigrationsResolver } from '@contember/schema-migrations
 export { typeDefs, devTypeDefs, Schema } from './schema'
 
 export {
-	Identity,
 	DatabaseContext,
-	setupSystemVariables,
-	StageBySlugQuery,
-	unnamedIdentity,
-	SchemaVersionBuilder,
+	DatabaseContextFactory,
 	formatSchemaName,
-	VersionedSchema,
-	ProjectInitializer,
+	getJunctionTables,
+	Identity,
 	LatestTransactionIdByStageQuery,
-	DatabaseContextFactory,
+	ProjectInitializer,
 	ProjectMigrator,
-	StageCreator,
-	getJunctionTables,
+	SchemaVersionBuilder,
+	setupSystemVariables,
 	Stage,
+	StageBySlugQuery,
+	StageCreator,
+	StagesQuery,
+	unnamedIdentity,
+	VersionedSchema,
 } from './model'
 export * from './SystemContainer'
 export * from './resolvers'

package/src/migrations/2020-05-06-150000-composed-primary.ts

@@ -1,6 +1,7 @@
 import { escapeValue, MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
+import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
 
 const createEventTrigger = (builder: MigrationBuilder, tableName: Name, primaryColumns: string[]) => {
 	builder.createTrigger(tableName, 'log_event', {
@@ -56,8 +57,8 @@ const migrateEvents = (builder: MigrationBuilder, tableName: string, primaryKeys
 `)
 }
 
-export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
-	const schema = await args.schemaResolver()
+export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
+	const schema = await args.schemaResolver(args.connection)
 	const tablesToMigrate = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	for (const table of tablesToMigrate) {

package/src/migrations/2020-06-01-103000-event-trigger-perf.ts

@@ -1,6 +1,7 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
+import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
 
 const createEventStatementTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_statement', {
@@ -14,8 +15,8 @@ const createEventStatementTrigger = (builder: MigrationBuilder, tableName: Name)
 	})
 }
 
-export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
-	const schema = await args.schemaResolver()
+export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
+	const schema = await args.schemaResolver(args.connection)
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	builder.sql(`CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$

package/src/migrations/2021-05-07-155800-event-log-rework.ts

@@ -1,6 +1,7 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
+import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
 
 const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_trx', {
@@ -16,8 +17,8 @@ const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 	})
 }
 
-export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
-	const schema = await args.schemaResolver()
+export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
+	const schema = await args.schemaResolver(args.connection)
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	builder.sql(`LOCK TABLE event`)

package/src/migrations/2021-05-19-1232000-event-log-fix-constraint.ts

@@ -1,6 +1,7 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
+import { MigrationArgs } from '@contember/database-migrations'
 
 const recreateTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	builder.dropTrigger(tableName, 'log_event_trx', { ifExists: true })
@@ -19,8 +20,8 @@ const recreateTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	})
 }
 
-export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
-	const schema = await args.schemaResolver()
+export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
+	const schema = await args.schemaResolver(args.connection)
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 

package/src/migrations/runner.ts

@@ -4,8 +4,9 @@ import composedPrimary from './2020-05-06-150000-composed-primary'
 import eventTriggerPerf from './2020-06-01-103000-event-trigger-perf'
 import eventLogRework from './2021-05-07-155800-event-log-rework'
 import eventLogFixConstraint from './2021-05-19-1232000-event-log-fix-constraint'
+import { SystemMigrationArgs } from './types'
 
-export const getSystemMigrations = (): Promise<Migration[]> => {
+export const getSystemMigrations = (): Promise<Migration<SystemMigrationArgs>[]> => {
 	return loadMigrations(process.env.CONTEMBER_SYSTEM_MIGRATIONS_DIR || __dirname, [
 		new Migration('2020-03-27-130000-project-migrations', projectMigrations),
 		new Migration('2020-05-06-150000-composed-primary', composedPrimary),

package/src/migrations/types.ts

@@ -1,7 +1,8 @@
 import { Schema } from '@contember/schema'
 import { ProjectConfig } from '../types'
+import { Connection } from '@contember/database'
 
 export interface SystemMigrationArgs {
-	schemaResolver: () => Promise<Schema>
+	schemaResolver: (connection: Connection.ConnectionLike) => Promise<Schema>
 	project: ProjectConfig
 }

package/src/model/ProjectInitializer.ts

@@ -4,15 +4,13 @@ import { StageCreator } from './stages'
 import { DatabaseContext, DatabaseContextFactory } from './database'
 import { SystemDbMigrationsRunnerFactory } from '../SystemContainer'
 import {
+	Client,
 	Connection,
 	createDatabaseIfNotExists,
-	DatabaseCredentials,
+	DatabaseConfig,
 	retryTransaction,
-	SingleConnection,
 } from '@contember/database'
 import { Logger } from '@contember/engine-common'
-import { Migration } from '@contember/schema-migrations'
-import { StagesQuery } from './queries'
 
 export class ProjectInitializer {
 	constructor(
@@ -24,45 +22,46 @@ export class ProjectInitializer {
 
 	public async initialize(
 		databaseContextFactory: DatabaseContextFactory,
-		project: ProjectConfig & { db?: DatabaseCredentials },
+		project: ProjectConfig & { db?: DatabaseConfig },
 		logger: Logger,
-		migrations?: Migration[],
 	) {
 		const dbContext = databaseContextFactory.create()
 		if (project.db) {
 			// todo: use dbContext
 			logger.group(`Executing system schema migration`)
 			await createDatabaseIfNotExists(project.db, logger.write.bind(logger))
-			const singleConnection = new SingleConnection(project.db, {})
-			const systemSchema = dbContext.client.schema
-			const dbContextMigrations = databaseContextFactory
-				.withClient(singleConnection.createClient(systemSchema, { module: 'system' }))
-				.create()
+			const singleConnection = Connection.createSingle(project.db)
+			await singleConnection.scope(async connection => {
+				const systemSchema = dbContext.client.schema
 
-			const schemaResolver = () => this.schemaVersionBuilder.buildSchema(dbContextMigrations)
-			await this.systemDbMigrationsRunnerFactory(singleConnection, systemSchema).migrate(
-				logger.write.bind(logger),
-				{
-					schemaResolver,
-					project,
-				},
-			)
+				const schemaResolver = (connection: Connection.ConnectionLike) => {
+					const dbContextMigrations = databaseContextFactory
+						.withClient(new Client(connection, systemSchema, { module: 'system' }))
+						.create()
+					return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
+				}
+				await this.systemDbMigrationsRunnerFactory(connection, systemSchema).migrate(
+					logger.write.bind(logger),
+					{
+						schemaResolver,
+						project,
+					},
+				)
+			})
 			await singleConnection.end()
 			logger.groupEnd()
 		}
-		return await retryTransaction(() =>
+		await retryTransaction(() =>
 			dbContext.transaction(async trx => {
-				await this.initStages(trx, project, logger, migrations)
+				await this.initStages(trx, project, logger)
 			}),
 		)
+		if (dbContext.client.connection instanceof Connection) {
+			await dbContext.client.connection.clearPool()
+		}
 	}
 
-	private async initStages(
-		db: DatabaseContext<Connection.TransactionLike>,
-		project: ProjectConfig,
-		logger: Logger,
-		migrations?: Migration[],
-	) {
+	private async initStages(db: DatabaseContext<Connection.TransactionLike>, project: ProjectConfig, logger: Logger) {
 
 		logger.group(`Creating stages`)
 
@@ -76,11 +75,5 @@ export class ProjectInitializer {
 		}
 
 		logger.groupEnd()
-		if (migrations) {
-			logger.group(`Executing project migrations`)
-			const stages = await db.queryHandler.fetch(new StagesQuery())
-			await this.projectMigrator.migrate(db, stages, migrations, logger.write.bind(logger))
-			logger.groupEnd()
-		}
 	}
 }

package/src/model/database/DatabaseContext.ts

@@ -1,4 +1,4 @@
-import { Client, Connection, DatabaseQueryable } from '@contember/database'
+import { Client, Connection, DatabaseQueryable, withDatabaseAdvisoryLock } from '@contember/database'
 import { QueryHandler } from '@contember/queryable'
 import { UuidProvider } from '../../utils'
 import { CommandBus } from '../commands'
@@ -7,6 +7,7 @@ export interface DatabaseContext<ConnectionType extends Connection.ConnectionLik
 	client: Client<ConnectionType>
 	queryHandler: QueryHandler<DatabaseQueryable>
 	transaction: <T>(cb: (db: DatabaseContext<Connection.TransactionLike>) => Promise<T> | T) => Promise<T>
+	locked: <T>(lock: number, cb: (db: DatabaseContext<Connection.ConnectionLike>) => Promise<T> | T) => Promise<T>
 	commandBus: CommandBus
 }
 
@@ -34,4 +35,5 @@ const createDatabaseContext = <ConnectionType extends Connection.ConnectionLike
 			return cb(createDatabaseContext(client, providers))
 		}),
 	commandBus: new CommandBus(client, providers),
+	locked: (lock, cb) => client.locked(lock, client => cb(createDatabaseContext(client, providers))),
 })

package/src/model/helpers/modelHelpers.ts

@@ -5,7 +5,7 @@ export const getJunctionTables = (model: Model.Schema): Model.JoiningTable[] =>
 	const tables: Model.JoiningTable[] = []
 	Object.values(model.entities).forEach(entity => {
 		acceptEveryFieldVisitor(model, entity, {
-			visitManyHasManyOwning: ({}, relation) => {
+			visitManyHasManyOwning: ({ relation }) => {
 				tables.push(relation.joiningTable)
 			},
 			visitColumn: () => {},

package/src/model/migrations/ProjectMigrator.ts

@@ -1,6 +1,5 @@
-import { Migration, MigrationDescriber } from '@contember/schema-migrations'
+import { calculateMigrationChecksum, Migration, MigrationDescriber } from '@contember/schema-migrations'
 import { Client, QueryError, wrapIdentifier } from '@contember/database'
-import { formatSchemaName } from '../helpers'
 import { Schema } from '@contember/schema'
 import { SaveMigrationCommand } from '../commands'
 import { Stage } from '../dtos'
@@ -21,19 +20,20 @@ export class ProjectMigrator {
 		db: DatabaseContext,
 		stages: Stage[],
 		migrationsToExecute: readonly Migration[],
-		logger: (message: string) => void,
-		ignoreOrder: boolean = false,
+		{ ignoreOrder = false, skipExecuted = false }: {
+			ignoreOrder?: boolean
+			skipExecuted?: boolean
+		},
 	) {
 		if (migrationsToExecute.length === 0) {
 			return
 		}
 		let { version, notNormalized, ...schema }  = await this.schemaVersionBuilder.buildSchema(db)
-		await this.validateMigrations(db, schema, version, migrationsToExecute, ignoreOrder)
+		const validated = await this.validateMigrations(db, schema, version, migrationsToExecute, { ignoreOrder, skipExecuted })
 
-		const sorted = [...migrationsToExecute].sort((a, b) => a.version.localeCompare(b.version))
+		const sorted = [...validated].sort((a, b) => a.version.localeCompare(b.version))
 
 		for (const migration of sorted) {
-			logger(`Executing migration ${migration.name}...`)
 			const formatVersion = migration.formatVersion
 
 			for (const modification of migration.modifications) {
@@ -48,10 +48,7 @@ export class ProjectMigrator {
 				)
 			}
 			await db.commandBus.execute(new SaveMigrationCommand(migration))
-			logger(`Done`)
 		}
-
-		logger(`Done`)
 	}
 
 	private async validateMigrations(
@@ -59,12 +56,21 @@ export class ProjectMigrator {
 		schema: Schema,
 		version: string,
 		migrationsToExecute: readonly Migration[],
-		ignoreOrder: boolean = false,
-	) {
+		{ ignoreOrder, skipExecuted }: {
+			ignoreOrder: boolean
+			skipExecuted: boolean
+		},
+	): Promise<readonly Migration[]> {
 		const executedMigrations = await this.executedMigrationsResolver.getMigrations(db)
+		const toExecute = []
 		for (const migration of migrationsToExecute) {
-			if (executedMigrations.find(it => it.version === migration.version)) {
-				throw new AlreadyExecutedMigrationError(migration.version, `Migration is already executed`)
+			const executedMigration = executedMigrations.find(it => it.version === migration.version)
+			if (executedMigration) {
+				if (skipExecuted && executedMigration.checksum === calculateMigrationChecksum(migration)) {
+					continue
+				} else {
+					throw new AlreadyExecutedMigrationError(migration.version, `Migration is already executed`)
+				}
 			}
 			if (migration.version < version && !ignoreOrder) {
 				throw new MustFollowLatestMigrationError(migration.version, `Must follow latest executed migration ${version}`)
@@ -83,7 +89,9 @@ export class ProjectMigrator {
 					errors.map(it => it.path.join('.') + ': ' + it.message).join('\n'),
 				)
 			}
+			toExecute.push(migration)
 		}
+		return toExecute
 	}
 
 	private async applyModification(

package/src/resolvers/mutation/MigrateMutationResolver.ts

@@ -5,6 +5,8 @@ import { MigrateResponse, MutationMigrateArgs } from '../../schema'
 import { Migration } from '@contember/schema-migrations'
 import { AuthorizationActions, MigrationError, ProjectMigrator, StagesQuery } from '../../model'
 
+const pg_lock_id = 1597474138739147
+
 export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 	constructor(private readonly projectMigrator: ProjectMigrator) {}
 
@@ -26,13 +28,16 @@ export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 	): Promise<MigrateResponse> {
 		const migrations = args.migrations as readonly Migration[]
 
-		return context.db.transaction(async trx => {
+		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(trx, stages, migrations, () => null, force)
+				await this.projectMigrator.migrate(trx, stages, migrations, {
+					ignoreOrder: force,
+					skipExecuted: true,
+				})
 			} catch (e) {
 				if (e instanceof MigrationError) {
 					await trx.client.connection.rollback()
@@ -54,6 +59,6 @@ export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 				ok: true,
 				errors: [],
 			}
-		})
+		}))
 	}
 }