@contember/schema-migrations 1.4.0-alpha.2 → 1.4.0-alpha.4

package/src/MigrationCreator.ts

@@ -1,50 +0,0 @@
-import { MigrationFilesManager } from './MigrationFilesManager'
-import { Schema } from '@contember/schema'
-import { SchemaDiffer } from './SchemaDiffer'
-import { VERSION_LATEST } from './modifications/ModificationVersions'
-import { Migration } from './Migration'
-import { MigrationVersionHelper } from '@contember/engine-common'
-
-export class MigrationCreator {
-	constructor(
-		private readonly migrationFilesManager: MigrationFilesManager,
-		private readonly schemaDiffer: SchemaDiffer,
-	) {}
-
-	async prepareMigration(
-		initialSchema: Schema,
-		newSchema: Schema,
-		migrationName: string,
-		{ skipInitialSchemaValidation = false }: { skipInitialSchemaValidation?: boolean } = {},
-	): Promise<{ migration: Migration; initialSchema: Schema } | null> {
-		await this.migrationFilesManager.createDirIfNotExist()
-
-		const modifications = this.schemaDiffer.diffSchemas(initialSchema, newSchema, { skipInitialSchemaValidation })
-		if (modifications.length === 0) {
-			return null
-		}
-
-		const migration = this.createMigration(modifications, migrationName)
-
-		return { initialSchema, migration }
-	}
-
-	async saveMigration(migration: Migration): Promise<string> {
-		const jsonDiff = MigrationCreator.createContent(migration)
-		const filename = await this.migrationFilesManager.createFile(jsonDiff, migration.name)
-		return filename
-	}
-
-	async removeMigration(name: string): Promise<void> {
-		await this.migrationFilesManager.removeFile(name)
-	}
-
-	private createMigration(modifications: Migration.Modification[], name: string): Migration {
-		const [version, fullName] = MigrationVersionHelper.createVersion(name)
-		return { formatVersion: VERSION_LATEST, modifications, version, name: fullName }
-	}
-
-	public static createContent({ modifications, formatVersion }: Migration): string {
-		return JSON.stringify({ formatVersion, modifications }, undefined, '\t') + '\n'
-	}
-}

package/src/MigrationFilesManager.ts

@@ -1,91 +0,0 @@
-import { MigrationVersionHelper } from '@contember/engine-common'
-import * as fs from 'node:fs/promises'
-import * as path from 'node:path'
-
-class MigrationFilesManager {
-	constructor(public readonly directory: string) {}
-
-	public async createFile(content: string, name: string): Promise<string> {
-		const path = this.formatPath(name)
-		await fs.writeFile(path, content, { encoding: 'utf8' })
-		return await fs.realpath(path)
-	}
-
-	public async removeFile(name: string) {
-		const path = this.formatPath(name)
-		await fs.unlink(path)
-	}
-
-	public async moveFile(oldName: string, newName: string) {
-		await fs.rename(this.formatPath(oldName), this.formatPath(newName))
-	}
-
-	public async createDirIfNotExist(): Promise<void> {
-		try {
-			await fs.mkdir(this.directory)
-		} catch (e) {
-			if (!(e instanceof Error) || !('code' in e) || (e as any).code !== 'EEXIST') {
-				throw e
-			}
-		}
-	}
-
-	public async listFiles(): Promise<string[]> {
-		const files: string[] = await this.tryReadDir()
-
-		const filteredFiles: string[] = await Promise.all(
-			files
-				.filter(file => file.endsWith(`.json`))
-				.filter(async file => {
-					return (await fs.lstat(`${this.directory}/${file}`)).isFile()
-				}),
-		)
-		return filteredFiles.sort()
-	}
-
-	private async tryReadDir(): Promise<string[]> {
-		try {
-			return await fs.readdir(this.directory)
-		} catch (e) {
-			if (e instanceof Error && 'code' in e && (e as any).code === 'ENOENT') {
-				return []
-			}
-			throw e
-		}
-	}
-
-	public async readFiles(predicate?: (version: string) => boolean): Promise<MigrationFilesManager.MigrationFile[]> {
-		let files = await this.listFiles()
-		if (predicate) {
-			files = files.filter(filename => predicate(MigrationVersionHelper.extractVersion(filename)))
-		}
-		const filesWithContent = files.map(async filename => ({
-			filename: filename,
-			path: `${this.directory}/${filename}`,
-			content: await fs.readFile(`${this.directory}/${filename}`, { encoding: 'utf8' }),
-		}))
-
-		return await Promise.all(filesWithContent)
-	}
-
-	public static createForProject(projectsDirectory: string, projectSlug: string): MigrationFilesManager {
-		const migrationsDir = path.join(projectsDirectory, projectSlug, 'migrations')
-		return new MigrationFilesManager(migrationsDir)
-	}
-
-	private formatPath(version: string) {
-		const filename = `${version}.json`
-		const path = `${this.directory}/${filename}`
-		return path
-	}
-}
-
-namespace MigrationFilesManager {
-	export type MigrationFile = {
-		filename: string
-		path: string
-		content: string
-	}
-}
-
-export { MigrationFilesManager }

package/src/MigrationsResolver.ts

@@ -1,25 +0,0 @@
-import { MigrationFilesManager } from './MigrationFilesManager'
-import { VERSION_INITIAL } from './modifications/ModificationVersions'
-import { MigrationVersionHelper } from '@contember/engine-common'
-import { Migration } from './Migration'
-
-export class MigrationsResolver {
-	constructor(private readonly migrationFilesManager: MigrationFilesManager) {}
-
-	public get directory(): string {
-		return this.migrationFilesManager.directory
-	}
-
-	public async getMigrations(): Promise<Migration[]> {
-		return (await this.migrationFilesManager.readFiles()).map(({ filename, content }) => {
-			const parsed = JSON.parse(content)
-			return {
-				version: MigrationVersionHelper.extractVersion(filename),
-				name: MigrationVersionHelper.extractName(filename),
-				formatVersion: parsed.formatVersion || VERSION_INITIAL,
-				modifications: parsed.modifications,
-				...(parsed.skippedErrors ? { skippedErrors: parsed.skippedErrors } : {}),
-			}
-		})
-	}
-}

package/src/SchemaVersionBuilder.ts

@@ -1,33 +0,0 @@
-import { Schema } from '@contember/schema'
-import { emptySchema } from '@contember/schema-utils'
-import { SchemaMigrator } from './SchemaMigrator'
-import { MigrationsResolver } from './MigrationsResolver'
-
-export class SchemaVersionBuilder {
-	constructor(
-		private readonly migrationsResolver: MigrationsResolver,
-		private readonly schemaMigrator: SchemaMigrator,
-	) {}
-
-	async buildSchema(targetVersion?: string): Promise<Schema> {
-		return this.buildSchemaAdvanced(emptySchema, version => !targetVersion || version <= targetVersion)
-	}
-
-	async buildSchemaUntil(targetVersion: string): Promise<Schema> {
-		return this.buildSchemaAdvanced(emptySchema, version => version < targetVersion)
-	}
-
-	async continue(schema: Schema, previousVersion: string | null, targetVersion: string): Promise<Schema> {
-		return this.buildSchemaAdvanced(schema, version => version <= targetVersion && version > (previousVersion || ''))
-	}
-
-	public async buildSchemaAdvanced(initialSchema: Schema, condition: (version: string) => boolean): Promise<Schema> {
-		return (await this.migrationsResolver.getMigrations())
-			.filter(({ version }) => condition(version))
-			.reduce<Schema>(
-				(schema, { modifications, formatVersion }) =>
-					this.schemaMigrator.applyModifications(schema, modifications, formatVersion),
-				initialSchema,
-			)
-	}
-}

package/tests/scripts/checkCreateConsistentMigrations.ts

@@ -1,32 +0,0 @@
-import { relative } from 'node:path'
-import {
-	MigrationFilesManager,
-	MigrationsResolver,
-	ModificationHandlerFactory,
-	SchemaDiffer,
-	SchemaMigrator,
-} from '../../src'
-import { emptySchema, schemaType } from '@contember/schema-utils'
-;(async () => {
-	// eslint-disable-next-line no-console
-	console.log(relative(process.cwd(), process.argv[2]))
-	const migrationsResolver = new MigrationsResolver(new MigrationFilesManager(relative(process.cwd(), process.argv[2])))
-	const modificationHandlerFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
-	const differ = new SchemaDiffer(new SchemaMigrator(modificationHandlerFactory))
-	const migrator = new SchemaMigrator(modificationHandlerFactory)
-	let schema = emptySchema
-	for (const migration of await migrationsResolver.getMigrations()) {
-		const nextSchema = migrator.applyModifications(schema, migration.modifications, migration.formatVersion)
-		schemaType(nextSchema)
-		const nextSchemaWithoutMeta = nextSchema
-		differ.diffSchemas(schema, nextSchemaWithoutMeta)
-
-		schema = nextSchema
-	}
-	// eslint-disable-next-line no-console
-	console.log('OK')
-})().catch(e => {
-	// eslint-disable-next-line no-console
-	console.error(e)
-	process.exit(1)
-})