@contember/migrations-client 2.2.0-alpha.7 → 2.2.0-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/migrations-client",
-  "version": "2.2.0-alpha.7",
+  "version": "2.2.0-alpha.9",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -26,11 +26,11 @@
     "test": "echo 'No tests'"
   },
   "dependencies": {
-    "@contember/engine-common": "2.2.0-alpha.7",
-    "@contember/graphql-client": "2.2.0-alpha.7",
-    "@contember/schema": "2.2.0-alpha.7",
-    "@contember/schema-migrations": "2.2.0-alpha.7",
-    "@contember/schema-utils": "2.2.0-alpha.7"
+    "@contember/engine-common": "2.2.0-alpha.9",
+    "@contember/graphql-client": "2.2.0-alpha.9",
+    "@contember/schema": "2.2.0-alpha.9",
+    "@contember/schema-migrations": "2.2.0-alpha.9",
+    "@contember/schema-utils": "2.2.0-alpha.9"
   },
   "devDependencies": {
     "@types/node": "^24.12.0"

package/src/SchemaVersionBuilder.ts

@@ -1,10 +1,12 @@
 import { Schema } from '@contember/schema'
 import { emptySchema } from '@contember/schema-utils'
-import { SchemaMigrator } from '@contember/schema-migrations'
+import { Migration, SchemaMigrator } from '@contember/schema-migrations'
 import { MigrationsResolver } from './MigrationsResolver.js'
 import { SchemaStateManager } from './SchemaStateManager.js'
 
 export class SchemaVersionBuilder {
+	private lastBuildUntil: { migrations: Migration[]; schema: Schema } | null = null
+
 	constructor(
 		private readonly migrationsResolver: MigrationsResolver,
 		private readonly schemaMigrator: SchemaMigrator,
@@ -20,8 +22,21 @@ export class SchemaVersionBuilder {
 		return schema
 	}
 
+	/**
+	 * Content migrations call this once each, with ascending versions. Continuing from the previous
+	 * build keeps a run linear instead of replaying every schema migration from scratch each time.
+	 */
 	async buildSchemaUntil(targetVersion: string): Promise<Schema> {
-		return this.buildSchemaAdvanced(emptySchema, version => version < targetVersion)
+		const migrations = (await this.migrationsResolver.getSchemaMigrations()).filter(({ version }) => version < targetVersion)
+		const previous = this.lastBuildUntil
+		const canContinue = previous !== null
+			&& previous.migrations.length <= migrations.length
+			&& previous.migrations.every((migration, index) => migration === migrations[index])
+		const start = canContinue ? previous : { migrations: [], schema: emptySchema }
+
+		const schema = this.applyMigrations(start.schema, migrations.slice(start.migrations.length))
+		this.lastBuildUntil = { migrations, schema }
+		return schema
 	}
 
 	async continue(schema: Schema, previousVersion: string | null, targetVersion: string): Promise<Schema> {
@@ -29,11 +44,14 @@ export class SchemaVersionBuilder {
 	}
 
 	public async buildSchemaAdvanced(initialSchema: Schema, condition: (version: string) => boolean): Promise<Schema> {
-		return (await this.migrationsResolver.getSchemaMigrations())
-			.filter(({ version }) => condition(version))
-			.reduce<Schema>(
-				(schema, { modifications, formatVersion }) => this.schemaMigrator.applyModifications(schema, modifications, formatVersion),
-				initialSchema,
-			)
+		const migrations = (await this.migrationsResolver.getSchemaMigrations()).filter(({ version }) => condition(version))
+		return this.applyMigrations(initialSchema, migrations)
+	}
+
+	private applyMigrations(initialSchema: Schema, migrations: Migration[]): Schema {
+		return migrations.reduce<Schema>(
+			(schema, { modifications, formatVersion }) => this.schemaMigrator.applyModifications(schema, modifications, formatVersion),
+			initialSchema,
+		)
 	}
 }

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

@@ -2,8 +2,15 @@ import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
 import * as path from 'node:path'
-import { MigrationsResolver, SchemaStateManager, SchemaVersionBuilder } from '../../../src/index.js'
-import { ModificationHandlerFactory, SchemaMigrator } from '@contember/schema-migrations'
+import {
+	JsonLoader,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+} from '../../../src/index.js'
+import { Migration, ModificationHandlerFactory, SchemaMigrator } from '@contember/schema-migrations'
 import { emptySchema } from '@contember/schema-utils'
 import { Schema } from '@contember/schema'
 
@@ -56,3 +63,63 @@ describe('SchemaVersionBuilder schema state merge', () => {
 		expect(schema.acl).toStrictEqual(emptySchema.acl)
 	})
 })
+
+class CountingSchemaMigrator extends SchemaMigrator {
+	public appliedMigrations = 0
+
+	constructor() {
+		super(new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
+	}
+
+	public override applyModifications(schema: Schema, diff: readonly Migration.Modification[], formatVersion: number): Schema {
+		this.appliedMigrations++
+		return super.applyModifications(schema, diff, formatVersion)
+	}
+}
+
+describe('SchemaVersionBuilder buildSchemaUntil', () => {
+	let migrationsDir: string
+	let filesManager: MigrationFilesManager
+	let migrator: CountingSchemaMigrator
+	let builder: SchemaVersionBuilder
+
+	const createEnumMigration = (version: string, enumName: string) =>
+		filesManager.createFile(
+			JSON.stringify({ formatVersion: 6, modifications: [{ modification: 'createEnum', enumName, values: ['a'] }] }),
+			`${version}-${enumName}`,
+		)
+	const enumNames = (schema: Schema) => Object.keys(schema.model.enums)
+
+	beforeEach(async () => {
+		migrationsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-svb-until-'))
+		filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+		migrator = new CountingSchemaMigrator()
+		builder = new SchemaVersionBuilder(new MigrationsResolver(filesManager), migrator, new SchemaStateManager(path.join(migrationsDir, 'state')))
+		await createEnumMigration('2024-01-01-000000', 'first')
+		await createEnumMigration('2024-01-02-000000', 'second')
+		await createEnumMigration('2024-01-03-000000', 'third')
+	})
+
+	afterEach(async () => {
+		await fs.rm(migrationsDir, { recursive: true, force: true })
+	})
+
+	test('continues from the previous build for an ascending target', async () => {
+		expect(enumNames(await builder.buildSchemaUntil('2024-01-02-000000'))).toStrictEqual(['first'])
+		expect(enumNames(await builder.buildSchemaUntil('2024-01-04-000000'))).toStrictEqual(['first', 'second', 'third'])
+		expect(migrator.appliedMigrations).toBe(3)
+	})
+
+	test('rebuilds from scratch for a descending target', async () => {
+		await builder.buildSchemaUntil('2024-01-04-000000')
+
+		expect(enumNames(await builder.buildSchemaUntil('2024-01-02-000000'))).toStrictEqual(['first'])
+	})
+
+	test('rebuilds from scratch when the migration files change', async () => {
+		await builder.buildSchemaUntil('2024-01-03-000000')
+		await createEnumMigration('2024-01-01-120000', 'inserted')
+
+		expect(enumNames(await builder.buildSchemaUntil('2024-01-04-000000'))).toStrictEqual(['first', 'inserted', 'second', 'third'])
+	})
+})