@contember/cli 1.4.0-alpha.1 → 1.4.0-alpha.3

package/src/commands/migrations/MigrationDiffCommand.ts

@@ -1,9 +1,9 @@
 import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
 import { printValidationErrors } from '../../utils/schema'
 import { InvalidSchemaException } from '@contember/schema-migrations'
-import { executeCreateMigrationCommand } from './MigrationCreateHelper'
-import { createMigrationStatusTable, printMigrationDescription } from '../../utils/migrations'
-import { executeMigrations, resolveMigrationStatus } from './MigrationExecuteHelper'
+import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
+import { createMigrationStatusTable, printMigrationDescription } from '../../utils/migrations/migrations'
+import { executeMigrations, resolveMigrationStatus } from '../../utils/migrations/MigrationExecuteHelper'
 import prompts from 'prompts'
 import { interactiveResolveApiToken, TenantClient } from '../../utils/tenant'
 import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
@@ -110,6 +110,11 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 							requireConfirmation: status.migrationsToExecute.length > 1 && !yes,
 							schemaVersionBuilder,
 							migrationDescriber,
+							contentMigrationFactoryArgs: {
+								apiToken,
+								apiBaseUrl: instance.baseUrl.replace(/\/$/, ''),
+								projectName: project.name,
+							},
 						})
 					}
 					return 0

package/src/commands/migrations/MigrationExecuteCommand.ts

@@ -1,12 +1,12 @@
 import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../MigrationsContainer'
+import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
 import {
 	configureExecuteMigrationCommand,
 	ExecuteMigrationOptions,
 	executeMigrations,
 	resolveMigrationStatus,
-} from './MigrationExecuteHelper'
-import { createMigrationStatusTable } from '../../utils/migrations'
+} from '../../utils/migrations/MigrationExecuteHelper'
+import { createMigrationStatusTable } from '../../utils/migrations/migrations'
 import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
 import { interactiveResolveApiToken, TenantClient } from '../../utils/tenant'
 import { SystemClient } from '../../utils/system'
@@ -90,6 +90,11 @@ export class MigrationExecuteCommand extends Command<Args, Options> {
 				migrations,
 				requireConfirmation: !input.getOption('yes'),
 				force: force,
+				contentMigrationFactoryArgs: {
+					apiToken,
+					apiBaseUrl: instance.baseUrl.replace(/\/$/, ''),
+					projectName: remoteProject,
+				},
 			})
 			code ||= singleCode
 		}

package/src/commands/migrations/MigrationRebaseCommand.ts

@@ -1,7 +1,6 @@
 import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
 import { MigrationVersionHelper } from '@contember/schema-migrations'
-import { executeCreateMigrationCommand } from './MigrationCreateHelper'
-import { getMigrationByName } from '../../utils/migrations'
+import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
 import { resolveSystemApiClient } from './SystemApiClientResolver'
 import { emptySchema } from '@contember/schema-utils'
 import { validateMigrations } from './MigrationValidationHelper'
@@ -52,7 +51,7 @@ export class MigrationRebaseCommand extends Command<Args, Options> {
 				const migrationNames = input.getArgument('migration')
 				const migrations = []
 				for (const migrationName of migrationNames) {
-					const migration = await getMigrationByName(migrationsResolver, migrationName)
+					const migration = await migrationsResolver.findSchemaMigrationByVersion(migrationName)
 					if (!migration) {
 						throw `Migration ${migrationName} not found`
 					}

package/src/commands/migrations/MigrationStatusCommand.ts

@@ -1,11 +1,11 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../MigrationsContainer'
+import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
+import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
 import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
 import { interactiveResolveApiToken } from '../../utils/tenant'
 import { SystemClient } from '../../utils/system'
-import { createMigrationStatusTable, getMigrationsStatus, MigrationState, sortMigrations } from '../../utils/migrations'
+import { createMigrationStatusTable, MigrationState, sortMigrations } from '../../utils/migrations/migrations'
 import chalk from 'chalk'
-import { Workspace } from '@contember/cli-common'
+import { resolveMigrationStatus } from '../../utils/migrations/MigrationExecuteHelper'
 
 type Args = {
 	project?: string
@@ -66,9 +66,7 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 		const remoteProject = input.getOption('remote-project') || project.name
 		const client = SystemClient.create(instance.baseUrl, remoteProject, apiToken)
 
-		const executedMigrations = await client.listExecutedMigrations()
-		let localMigrations = await container.migrationsResolver.getMigrations()
-		let status = getMigrationsStatus(executedMigrations, localMigrations)
+		let status = await resolveMigrationStatus(client, container.migrationsResolver)
 		const restoreMissing = input.getOption('restore-missing')
 		if (restoreMissing) {
 			const missing = status.errorMigrations.filter(it => it.state === MigrationState.EXECUTED_MISSING)
@@ -87,8 +85,7 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 					fullMigration.name,
 				)
 			}
-			localMigrations = await container.migrationsResolver.getMigrations()
-			status = getMigrationsStatus(executedMigrations, localMigrations)
+			status = await resolveMigrationStatus(client, container.migrationsResolver)
 		}
 
 		const onlyErrors = input.getOption('only-errors')

package/src/commands/migrations/index.ts

@@ -1,4 +1,5 @@
 export * from './MigrationAmendCommand'
+export * from './MigrationBlankCommand'
 export * from './MigrationDescribeCommand'
 export * from './MigrationDiffCommand'
 export * from './MigrationExecuteCommand'

package/src/commands/project/ProjectValidateCommand.ts

@@ -1,5 +1,5 @@
 import { Command, CommandConfiguration, Input, validateProjectName, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../MigrationsContainer'
+import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
 import { validateSchemaAndPrintErrors } from '../../utils/schema'
 import { emptySchema } from '@contember/schema-utils'
 import { validateMigrations } from '../migrations/MigrationValidationHelper'
@@ -39,7 +39,7 @@ export class ProjectValidateCommand extends Command<Args, Options> {
 			console.group(`Project ${project.name}:`)
 			const migrationsDir = await project.migrationsDir
 			const container = new MigrationsContainerFactory(migrationsDir).create()
-			const migrations = await container.migrationsResolver.getMigrations()
+			const migrations = await container.migrationsResolver.getSchemaMigrations()
 			let projectValid = await validateMigrations(
 				emptySchema,
 				migrations,

package/src/run.ts

@@ -5,6 +5,7 @@ import {
 	DeployCommand,
 	InviteCommand,
 	MigrationAmendCommand,
+	MigrationBlankCommand,
 	MigrationDescribeCommand,
 	MigrationDiffCommand,
 	MigrationExecuteCommand,
@@ -35,6 +36,7 @@ import { checkVersions } from './utils/checkVersions';
 		['data:transfer']: () => new TransferCommand(workspace),
 		['migrations:diff']: () => new MigrationDiffCommand(workspace),
 		['migrations:amend']: () => new MigrationAmendCommand(workspace),
+		['migrations:blank']: () => new MigrationBlankCommand(workspace),
 		['migrations:describe']: () => new MigrationDescribeCommand(workspace),
 		['migrations:execute']: () => new MigrationExecuteCommand(workspace),
 		['migrations:rebase']: () => new MigrationRebaseCommand(workspace),

package/src/tsconfig.json

@@ -12,6 +12,7 @@
 		{ "path": "../../config-loader/src" },
 		{ "path": "../../database/src" },
 		{ "path": "../../dic/src" },
+		{ "path": "../../engine-common/src" },
 		{ "path": "../../engine-content-api/src" },
 		{ "path": "../../schema/src" },
 		{ "path": "../../schema-migrations/src" },

package/src/utils/admin.ts

@@ -1,4 +1,3 @@
-import fetch, { Response } from 'node-fetch'
 import { readdir, readFile } from 'node:fs/promises'
 import { maskToken } from './token'
 

package/src/utils/esbuild.ts

@@ -0,0 +1,14 @@
+import * as esbuild from 'esbuild'
+
+export const buildJs = async (path: string): Promise<string> => {
+	const response = await esbuild.build({
+		entryPoints: [path],
+		platform: 'node',
+		bundle: true,
+		treeShaking: true,
+		write: false,
+		loader: { '.sql': 'text' },
+		external: ['@contember/admin', 'react', 'react/jsx-runtime'],
+	})
+	return response.outputFiles[0].text
+}

package/src/utils/migrations/JsLoader.ts

@@ -0,0 +1,37 @@
+import { MigrationFileLoader } from './MigrationFileLoader'
+import { buildJs } from '../esbuild'
+import { MigrationParser } from './MigrationParser'
+import { ContentMigration, MigrationContent, MigrationFile } from './MigrationFile'
+
+export class JsLoader implements MigrationFileLoader {
+	constructor(
+		private readonly migrationParser: MigrationParser,
+	) {
+	}
+
+
+	public async load(file: MigrationFile): Promise<MigrationContent> {
+		const code = await buildJs(file.path)
+		const fn = new Function(`var module = {}; ((module) => { ${code} })(module); return module`)
+		const exports = fn().exports
+		if (!('default' in exports) && !('query' in exports) && !('queries' in exports)) {
+			throw `export "default" or "query" is required in ${file.path}`
+		}
+		if (typeof exports.default !== 'function') {
+			return this.migrationParser.parse(file, exports.default || exports)
+		}
+
+		return {
+			type: 'factory',
+			factory: async (): Promise<ContentMigration> => {
+				const result = await exports.default()
+				const migration = this.migrationParser.parse(file, result ?? { queries: [] })
+				if (migration.type !== 'content') {
+					throw new Error()
+				}
+				return migration
+			},
+
+		}
+	}
+}

package/src/utils/migrations/JsonLoader.ts

@@ -0,0 +1,18 @@
+import { MigrationFileLoader } from './MigrationFileLoader'
+import fs from 'node:fs/promises'
+import { MigrationParser } from './MigrationParser'
+import { MigrationFile } from './MigrationFile'
+
+export class JsonLoader implements MigrationFileLoader {
+	constructor(
+		private readonly migrationParser: MigrationParser,
+	) {
+	}
+
+	public async load(file: MigrationFile) {
+		return this.migrationParser.parse(
+			file,
+			JSON.parse(await fs.readFile(file.path, { encoding: 'utf8' })),
+		)
+	}
+}

package/src/{commands → utils}/migrations/MigrationCreateHelper.ts

@@ -1,14 +1,10 @@
-import { CommandConfiguration, Input } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../MigrationsContainer'
-import {
-	MigrationCreator,
-	MigrationDescriber,
-	MigrationFilesManager,
-	MigrationsResolver,
-	SchemaMigrator,
-	SchemaVersionBuilder,
-} from '@contember/schema-migrations'
-import { Workspace, Project } from '@contember/cli-common'
+import { Input, Project, Workspace } from '@contember/cli-common'
+import { MigrationsContainerFactory } from './MigrationsContainer'
+import { MigrationDescriber, SchemaMigrator } from '@contember/schema-migrations'
+import { MigrationCreator } from './MigrationCreator'
+import { MigrationsResolver } from './MigrationsResolver'
+import { SchemaVersionBuilder } from './SchemaVersionBuilder'
+import { MigrationFilesManager } from './MigrationFilesManager'
 
 type Args = {
 	project?: string

package/src/utils/migrations/MigrationCreator.ts

@@ -0,0 +1,60 @@
+import { MigrationFilesManager } from './MigrationFilesManager'
+import { Schema } from '@contember/schema'
+import { Migration, SchemaDiffer, VERSION_LATEST } from '@contember/schema-migrations'
+import { MigrationVersionHelper } from '@contember/engine-common'
+
+export class MigrationCreator {
+	constructor(
+		private readonly migrationFilesManager: MigrationFilesManager,
+		private readonly schemaDiffer: SchemaDiffer,
+		private readonly emptyTemplates: Record<string, string> = {},
+	) {}
+
+	async createEmptyMigrationFile(migrationName: string, format: string): Promise<string> {
+		if (!this.emptyTemplates.hasOwnProperty(format)) {
+			throw new Error(`Unknown format ${format}`)
+		}
+		await this.migrationFilesManager.createDirIfNotExist()
+		const [, fullName] = MigrationVersionHelper.createVersion(migrationName)
+		const filename = await this.migrationFilesManager.createFile(this.emptyTemplates[format], fullName, format)
+
+		return filename
+	}
+
+	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/{commands → utils}/migrations/MigrationExecuteHelper.ts

@@ -1,8 +1,12 @@
 import { CommandConfiguration } from '@contember/cli-common'
-import { SystemClient } from '../../utils/system'
-import { getMigrationsStatus, MigrationToExecuteOkStatus, printMigrationDescription } from '../../utils/migrations'
-import { MigrationDescriber, MigrationsResolver, SchemaVersionBuilder } from '@contember/schema-migrations'
+import { SystemClient } from '../system'
+import { getMigrationsStatus, MigrationToExecuteOkStatus, printMigrationDescription } from './migrations'
+import { MigrationDescriber } from '@contember/schema-migrations'
 import prompts from 'prompts'
+import { MigrationsResolver } from './MigrationsResolver'
+import { SchemaVersionBuilder } from './SchemaVersionBuilder'
+import { ContentMigrationFactoryArgs, isSchemaMigration, ResolvedMigrationContent } from './MigrationFile'
+import { assertNever } from '../assertNever'
 
 export type ExecuteMigrationOptions = {
 	instance?: string
@@ -31,7 +35,7 @@ export const resolveMigrationStatus = async (
 	force: boolean = false,
 ): Promise<ReturnType<typeof getMigrationsStatus>> => {
 	const executedMigrations = await client.listExecutedMigrations()
-	const localMigrations = await migrationsResolver.getMigrations()
+	const localMigrations = await migrationsResolver.getMigrationFiles()
 	return getMigrationsStatus(executedMigrations, localMigrations, force)
 }
 
@@ -41,6 +45,7 @@ export const executeMigrations = async ({
 	requireConfirmation,
 	schemaVersionBuilder,
 	migrationDescriber,
+	contentMigrationFactoryArgs,
 	force,
 }: {
 	client: SystemClient
@@ -48,6 +53,7 @@ export const executeMigrations = async ({
 	requireConfirmation: boolean
 	schemaVersionBuilder: SchemaVersionBuilder
 	migrationDescriber: MigrationDescriber
+	contentMigrationFactoryArgs: ContentMigrationFactoryArgs
 	force?: boolean
 }): Promise<number> => {
 	if (migrations.length === 0) {
@@ -73,7 +79,12 @@ export const executeMigrations = async ({
 			if (action === 'describe') {
 				const schema = await schemaVersionBuilder.buildSchemaUntil(migrations[0].version)
 				for (const migration of migrations) {
-					await printMigrationDescription(migrationDescriber, schema, migration.localMigration, {
+					const migrationContent = await migration.localMigration.getContent()
+					if (!isSchemaMigration(migrationContent)) {
+						continue
+					}
+
+					await printMigrationDescription(migrationDescriber, schema, migrationContent, {
 						noSql: true,
 					})
 				}
@@ -85,10 +96,58 @@ export const executeMigrations = async ({
 		} while (true)
 	}
 
-	await client.migrate(
-		migrations.map(it => it.localMigration),
-		force,
-	)
+	let migrationsToRun: ResolvedMigrationContent[] = []
+
+	const executeMigrations = async () => {
+		if (migrationsToRun.length === 0) {
+			return
+		}
+		await client.migrate(
+			migrationsToRun.map(it => {
+				if (it.type === 'schema') {
+					return {
+						version: it.version,
+						name: it.name,
+						type: 'SCHEMA',
+						schemaMigration: {
+							formatVersion: it.formatVersion,
+							modifications: it.modifications,
+							skippedErrors: it.skippedErrors,
+						},
+					}
+				}
+				if (it.type === 'content') {
+					return {
+						version: it.version,
+						name: it.name,
+						type: 'CONTENT',
+						contentMigration: it.queries,
+					}
+				}
+				return assertNever(it)
+			}),
+			force,
+		)
+		migrationsToRun.forEach(it => {
+			console.log(it.name)
+		})
+		migrationsToRun = []
+	}
+
+	console.log('Executing...')
+
+	for (const migration of migrations) {
+		const migrationContent = await migration.localMigration.getContent()
+		if (migrationContent.type === 'factory') {
+			await executeMigrations()
+			const result = await migrationContent.factory(contentMigrationFactoryArgs)
+			migrationsToRun.push(result)
+			await executeMigrations()
+		} else {
+			migrationsToRun.push(migrationContent)
+		}
+	}
+	await executeMigrations()
 	console.log('Migration executed')
 	return 0
 }

package/src/utils/migrations/MigrationFile.ts

@@ -0,0 +1,52 @@
+import { Migration } from '@contember/schema-migrations'
+import { JSONObject } from '@contember/cli-common'
+
+export interface MigrationFile {
+	path: string
+	version: string
+	name: string
+
+	getContent: () => Promise<MigrationContent>
+}
+
+export const isSchemaMigration = (content: MigrationContent): content is SchemaMigration => typeof content !== 'function' && 'modifications' in content
+
+export type ResolvedMigrationContent =
+	| SchemaMigration
+	| ContentMigration
+
+export type MigrationContent =
+	| ResolvedMigrationContent
+	| ContentMigrationFactory
+
+export type SchemaMigration =
+	& {
+		type: 'schema'
+	}
+	& Migration
+
+export type ContentMigration = {
+	type: 'content'
+	version: string
+	name: string
+	queries: ContentMigrationQuery[]
+}
+
+export type ContentMigrationFactoryArgs = {
+	apiBaseUrl: string
+	projectName: string
+	apiToken: string
+}
+
+export type ContentMigrationFactory = {
+	type: 'factory'
+	factory: (args: ContentMigrationFactoryArgs) => Promise<ContentMigration>
+}
+
+export type ContentMigrationQuery = {
+	query: string
+	variables?: JSONObject
+	stage?: string
+	checkMutationResult?: boolean
+}
+

package/src/utils/migrations/MigrationFileLoader.ts

@@ -0,0 +1,5 @@
+import { MigrationContent, MigrationFile } from './MigrationFile'
+
+export interface MigrationFileLoader {
+	load(file: MigrationFile): Promise<MigrationContent>
+}

package/src/utils/migrations/MigrationFilesManager.ts

@@ -0,0 +1,102 @@
+import { MigrationVersionHelper } from '@contember/engine-common'
+import * as fs from 'node:fs/promises'
+import { MigrationFileLoader } from './MigrationFileLoader'
+import { MigrationContent, MigrationFile } from './MigrationFile'
+import { join } from 'node:path'
+import { Dirent } from 'node:fs'
+
+export class MigrationFilesManager {
+	private migrations: null | Promise<MigrationFile[]> = null
+
+	constructor(
+		public readonly directory: string,
+		private readonly loaders: Record<string, MigrationFileLoader>,
+	) {}
+
+	public async createFile(content: string, name: string, extension = 'json'): Promise<string> {
+		this.migrations = null
+		const path = this.formatPath(name, extension)
+		await fs.writeFile(path, content, { encoding: 'utf8' })
+		return await fs.realpath(path)
+	}
+
+	public async removeFile(name: string) {
+		this.migrations = null
+		const path = this.formatPath(name)
+		await fs.unlink(path)
+	}
+
+	public async moveFile(oldName: string, newName: string) {
+		this.migrations = null
+		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 readFiles(): Promise<MigrationFile[]> {
+		return this.migrations ??= this.forceReadFiles()
+	}
+
+	public async forceReadFiles(): Promise<MigrationFile[]> {
+		const files = (await this.listFiles()).map(it => ({
+			filename: it,
+			version: MigrationVersionHelper.extractVersion(it),
+		}))
+
+		return files.map(({ version, filename }): MigrationFile => {
+			const ext = filename.substring(filename.lastIndexOf('.') + 1)
+			const path = join(this.directory, filename)
+			let content: Promise<MigrationContent> | null = null
+			const file: MigrationFile = {
+				path: path,
+				version: version,
+				name: MigrationVersionHelper.extractName(path.substring(path.lastIndexOf('/') + 1)),
+				getContent: () => {
+					content ??= this.loaders[ext].load(file)
+					return content
+				},
+			}
+			return file
+		})
+	}
+
+	private async tryReadDir(): Promise<Dirent[]> {
+		try {
+			return await fs.readdir(this.directory, { withFileTypes: true })
+		} catch (e) {
+			if (e instanceof Error && 'code' in e && (e as any).code === 'ENOENT') {
+				return []
+			}
+			throw e
+		}
+	}
+
+	private async listFiles(): Promise<string[]> {
+		const files = await this.tryReadDir()
+
+		const extensions = Object.keys(this.loaders).join('|')
+		const regex = new RegExp('^\\d{4}-\\d{2}-\\d{2}-\\d{6}-[\\w-]+\\.(' + extensions  + ')$')
+		const filteredFiles = await Promise.all(
+			files
+				.filter(it => it.isFile())
+				.map(it => it.name)
+				.filter(it => it.match(regex)),
+		)
+
+		return filteredFiles.sort()
+	}
+
+	private formatPath(version: string, extension = 'json'): string {
+		const filename = `${version}.${extension}`
+		const path = `${this.directory}/${filename}`
+		return path
+	}
+}

package/src/utils/migrations/MigrationParser.ts

@@ -0,0 +1,32 @@
+import { JSONValue } from '@contember/cli-common'
+import { Migration, VERSION_INITIAL } from '@contember/schema-migrations'
+import { ContentMigrationQuery, MigrationFile, ResolvedMigrationContent } from './MigrationFile'
+
+export class MigrationParser {
+	public parse(migrationFile: MigrationFile, content: JSONValue): ResolvedMigrationContent {
+		if (typeof content !== 'object' || content === null) {
+			throw new Error('Invalid migration')
+		}
+
+		if ('modifications' in content) {
+			const validated = content as Migration // todo validate
+
+			return {
+				type: 'schema',
+				version: migrationFile.version,
+				name: migrationFile.name,
+				formatVersion: validated.formatVersion || VERSION_INITIAL,
+				modifications: validated.modifications,
+				...(validated.skippedErrors ? { skippedErrors: validated.skippedErrors } : {}),
+			}
+		} else if ('queries' in content || 'query' in content) {
+			return {
+				type: 'content',
+				version: migrationFile.version,
+				name: migrationFile.name,
+				queries: ('queries' in content ? content.queries : [content]) as ContentMigrationQuery[],
+			}
+		}
+		throw new Error('Invalid migration content')
+	}
+}