@contember/cli 1.4.0-rc.7 → 2.0.0-alpha.10

package/src/utils/migrations/MigrationCreateHelper.ts

@@ -1,59 +0,0 @@
-import { Input, Project, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from './MigrationsContainer'
-import {
-	MigrationCreator,
-	MigrationDescriber,
-	MigrationFilesManager,
-	MigrationsResolver,
-	SchemaMigrator,
-	SchemaVersionBuilder,
-} from '@contember/migrations-client'
-
-type Args = {
-	project?: string
-	migrationName: string
-}
-
-type Options = {}
-
-export const executeCreateMigrationCommand = async (
-	input: Input<Pick<Args, 'project'>, Options>,
-	{ workspace }: {workspace: Workspace},
-	createMigrationCallback: (args: {
-		workspace: Workspace
-		project: Project
-		migrationCreator: MigrationCreator
-		migrationDescriber: MigrationDescriber
-		migrationsResolver: MigrationsResolver
-		schemaVersionBuilder: SchemaVersionBuilder
-		schemaMigrator: SchemaMigrator
-		migrationFilesManager: MigrationFilesManager
-	}) => Promise<number>,
-) => {
-	const projectName = input.getArgument('project')
-	const allProjects = projectName === '.'
-	const projects = allProjects
-		? await workspace.projects.listProjects()
-		: [await workspace.projects.getProject(projectName, { fuzzy: true })]
-
-	for (const project of projects) {
-		console.group(`Project ${project.name}:`)
-		const container = new MigrationsContainerFactory(project.migrationsDir).create()
-
-		const result = await createMigrationCallback({
-			project,
-			migrationCreator: container.migrationCreator,
-			migrationDescriber: container.migrationDescriber,
-			migrationsResolver: container.migrationsResolver,
-			schemaVersionBuilder: container.schemaVersionBuilder,
-			schemaMigrator: container.schemaMigrator,
-			migrationFilesManager: container.migrationFilesManager,
-			workspace,
-		})
-		console.groupEnd()
-		if (result > 0) {
-			return result
-		}
-	}
-	return 0
-}

package/src/utils/migrations/MigrationExecuteHelper.ts

@@ -1,115 +0,0 @@
-import { CommandConfiguration } from '@contember/cli-common'
-import {
-	ContentMigrationFactoryArgs,
-	isSchemaMigration,
-	MigrationDescriber,
-	MigrationsResolver,
-	MigrationToExecuteOkStatus,
-	SchemaVersionBuilder,
-	SystemClient,
-	MigrationExecutor,
-	MigrationsStatusResolver,
-} from '@contember/migrations-client'
-import { printMigrationDescription } from './migrations'
-import prompts from 'prompts'
-
-export type ExecuteMigrationOptions = {
-	instance?: string
-	['remote-project']?: string
-	yes?: true
-}
-
-export const configureExecuteMigrationCommand = (configuration: CommandConfiguration<{}, ExecuteMigrationOptions>) => {
-	configuration //
-		.option('instance')
-		.valueRequired()
-		.description('Local instance name or remote Contember API URL')
-	configuration //
-		.option('remote-project')
-		.valueRequired()
-		.description('Specify this when remote project name does not match local project name.')
-	configuration //
-		.option('yes')
-		.valueNone()
-		.description('Do not ask for confirmation.')
-}
-
-export const resolveMigrationStatus = async (
-	client: SystemClient,
-	migrationsResolver: MigrationsResolver,
-	force: boolean = false,
-) => {
-	const migrationStatusResolver = new MigrationsStatusResolver()
-	const executedMigrations = await client.listExecutedMigrations()
-	const localMigrations = await migrationsResolver.getMigrationFiles()
-	return migrationStatusResolver.getMigrationsStatus(executedMigrations, localMigrations, force)
-}
-
-export const executeMigrations = async ({
-	client,
-	migrations,
-	requireConfirmation,
-	schemaVersionBuilder,
-	migrationDescriber,
-	contentMigrationFactoryArgs,
-	force,
-}: {
-	client: SystemClient
-	migrations: MigrationToExecuteOkStatus[]
-	requireConfirmation: boolean
-	schemaVersionBuilder: SchemaVersionBuilder
-	migrationDescriber: MigrationDescriber
-	contentMigrationFactoryArgs: ContentMigrationFactoryArgs
-	force?: boolean
-}): Promise<number> => {
-	if (migrations.length === 0) {
-		return 0
-	}
-	console.log('Will execute following migrations:')
-	migrations.forEach(it => console.log(it.name))
-	if (requireConfirmation) {
-		if (!process.stdin.isTTY) {
-			throw 'TTY not available. Pass --yes option to confirm execution.'
-		}
-		do {
-			const { action } = await prompts({
-				type: 'select',
-				name: 'action',
-				message: 'Do you want to continue?',
-				choices: [
-					{ value: 'yes', title: 'Execute migrations' },
-					{ value: 'describe', title: 'Describe migrations' },
-					{ value: 'no', title: 'Abort' },
-				],
-			})
-			if (action === 'describe') {
-				const schema = await schemaVersionBuilder.buildSchemaUntil(migrations[0].version)
-				for (const migration of migrations) {
-					const migrationContent = await migration.localMigration.getContent()
-					if (!isSchemaMigration(migrationContent)) {
-						continue
-					}
-
-					await printMigrationDescription(migrationDescriber, schema, migrationContent, {
-						noSql: true,
-					})
-				}
-			} else if (action === 'yes') {
-				break
-			} else {
-				return 1
-			}
-		} while (true)
-	}
-
-	const executor = new MigrationExecutor()
-
-	await executor.executeMigrations({
-		client,
-		migrations,
-		contentMigrationFactoryArgs,
-		log: message => console.log(message),
-		force,
-	})
-	return 0
-}

package/src/utils/migrations/MigrationsContainer.ts

@@ -1,80 +0,0 @@
-import { Builder } from '@contember/dic'
-import { MigrationDescriber, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VERSION_LATEST } from '@contember/schema-migrations'
-import { MigrationCreator } from '@contember/migrations-client'
-import { SchemaVersionBuilder } from '@contember/migrations-client'
-import { MigrationsResolver } from '@contember/migrations-client'
-import { MigrationFilesManager } from '@contember/migrations-client'
-import { JsonLoader } from '@contember/migrations-client'
-import { MigrationParser } from '@contember/migrations-client'
-import { JsLoader } from '@contember/migrations-client'
-import { buildJs } from '../esbuild'
-
-export interface MigrationsContainer {
-	migrationCreator: MigrationCreator
-	migrationDescriber: MigrationDescriber
-	schemaVersionBuilder: SchemaVersionBuilder
-	schemaDiffer: SchemaDiffer
-	migrationsResolver: MigrationsResolver
-	migrationFilesManager: MigrationFilesManager
-	schemaMigrator: SchemaMigrator
-}
-
-const jsSample = `
-export const query = \`\`
-export const variables = {}
-
-// or multiple queries
-// export const queries = []
-
-// or a factory
-// export default async () => ({ queries: [] })
-`
-
-export class MigrationsContainerFactory {
-	constructor(private readonly directory: string) {}
-
-	public create(): MigrationsContainer {
-		return new Builder({})
-			.addService('migrationFilesManager', () => {
-				const jsExecutor = async (file: string) => {
-					const code = await buildJs(file)
-					const fn = new Function(`var module = {}; ((module) => { ${code} })(module); return module`)
-					return fn().exports
-				}
-
-				return new MigrationFilesManager(this.directory, {
-					json: new JsonLoader(new MigrationParser()),
-					ts: new JsLoader(new MigrationParser(), jsExecutor),
-					js: new JsLoader(new MigrationParser(), jsExecutor),
-				})
-			})
-			.addService('modificationHandlerFactory', () =>
-				new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
-			.addService('schemaMigrator', ({ modificationHandlerFactory }) =>
-				new SchemaMigrator(modificationHandlerFactory))
-			.addService('migrationsResolver', ({ migrationFilesManager }) =>
-				new MigrationsResolver(migrationFilesManager))
-			.addService('schemaVersionBuilder', ({ migrationsResolver, schemaMigrator }) =>
-				new SchemaVersionBuilder(migrationsResolver, schemaMigrator))
-			.addService('schemaDiffer', ({ schemaMigrator }) =>
-				new SchemaDiffer(schemaMigrator))
-			.addService('migrationCreator', ({ migrationFilesManager, schemaDiffer }) =>
-				new MigrationCreator(migrationFilesManager, schemaDiffer, {
-					json: JSON.stringify({ formatVersion: VERSION_LATEST, modifications: [] }, undefined, '\t') + '\n',
-					ts: jsSample,
-					js: jsSample,
-				}))
-			.addService('migrationDescriber', ({ modificationHandlerFactory }) =>
-				new MigrationDescriber(modificationHandlerFactory))
-			.build()
-			.pick(
-				'migrationCreator',
-				'migrationDescriber',
-				'schemaVersionBuilder',
-				'schemaDiffer',
-				'migrationsResolver',
-				'migrationFilesManager',
-				'schemaMigrator',
-			)
-	}
-}

package/src/utils/migrations/migrations.ts

@@ -1,80 +0,0 @@
-import { Migration, MigrationDescriber } from '@contember/schema-migrations'
-import chalk from 'chalk'
-import { Schema } from '@contember/schema'
-import chalkTable from 'chalk-table'
-import { assertNever } from '../assertNever'
-import { emptyDatabaseMetadata } from '@contember/database'
-import { MigrationState } from '@contember/migrations-client'
-import { AnyMigrationStatus } from '@contember/migrations-client'
-
-export const printMigrationDescription = function (
-	migrationsDescriber: MigrationDescriber,
-	schema: Schema,
-	migration: Migration,
-	options: { sqlOnly?: boolean; noSql?: boolean },
-) {
-	const description = migrationsDescriber.describeModifications(schema, migration)
-	description.forEach(({ modification, getSql, description }) => {
-		const sql = getSql({
-			systemSchema: 'system',
-			databaseMetadata: emptyDatabaseMetadata,
-			invalidateDatabaseMetadata: () => null,
-		})
-		if (options.sqlOnly) {
-			if (sql.trim()) {
-				console.log(sql)
-			}
-		} else {
-			const color = description.isDestructive ? chalk.red : chalk.blue
-			console.group(color(`${description.message} [${modification.modification}]`))
-			if (description.failureWarning) {
-				console.log(chalk.bgWhite(chalk.redBright(description.failureWarning)))
-			}
-
-			if (!options.noSql) {
-				if (sql.trim()) {
-					console.log(sql)
-				} else {
-					console.log('No sql to execute')
-				}
-			}
-			console.groupEnd()
-		}
-	})
-}
-
-export const createMigrationStatusTable = (migrations: AnyMigrationStatus[]): string => {
-	return chalkTable(
-		{
-			columns: ['status', 'migration', 'info'],
-		},
-		migrations.map(it => {
-			switch (it.state) {
-				case MigrationState.EXECUTED_ERROR:
-					return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
-				case MigrationState.EXECUTED_OK:
-					return {
-						status: chalk.bgGreen.blackBright('Executed'),
-						migration: it.name,
-						info: `Executed at ${it.executedMigration.executedAt.toISOString()}`,
-					}
-				case MigrationState.EXECUTED_MISSING:
-					return {
-						status: chalk.bgRedBright.white('ERROR'),
-						migration: it.name,
-						info: it.errorMessage,
-					}
-				case MigrationState.TO_EXECUTE_OK:
-					return {
-						status: chalk.bgBlueBright.white('Not executed'),
-						migration: it.name,
-						info: 'Will be executed during next deploy',
-					}
-				case MigrationState.TO_EXECUTE_ERROR:
-					return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
-				default:
-					assertNever(it)
-			}
-		}),
-	)
-}

package/src/utils/project/components/EntityInfo.tsx

@@ -1,82 +0,0 @@
-import { Model, Schema } from '@contember/schema'
-import { ReferencesMap } from '../../schema/collectReferences'
-import { formatEntityAnchor, formatFieldAnchor } from './utils'
-import { SinglePermission } from './SinglePermission'
-import { FieldType } from './FieldType'
-import { FieldPermissions } from './FieldPermissions'
-import { OnDelete } from './OnDelete'
-import { Fragment, h } from 'preact'
-
-interface EntityInfoProps {
-	entity: Model.Entity
-	schema: Schema
-	references: ReferencesMap
-}
-
-export const EntityInfo = ({ entity, schema, references }: EntityInfoProps) => (
-	<div class={'m-4 border border-gray-400 rounded-lg group'}
-		 id={formatEntityAnchor(entity.name)}>
-		<div class={'font-bold text-gray-900 py-2 px-4 border-b border-gray-400 group-target:bg-yellow-100 rounded-t-lg'}>
-			{entity.name}
-		</div>
-		<div class={'px-2 py-2 flex flex-wrap '}>
-			<div>
-				<table>
-					<thead>
-						<tr>
-							<th class={'text-left px-2 text-gray-500 font-normal w-[180px] max-w-[180px]'}>Name</th>
-							<th class={'text-left px-2 text-gray-500 font-normal w-[340px] max-w-[340px]'}>Type</th>
-							{Object.keys(schema.acl.roles).map(role => <th
-								class={'text-left px-2 text-gray-500 font-normal w-[120px] max-w-[120px] text-xs truncate text-sm'}>{role}</th>)}
-						</tr>
-					</thead>
-					<tr>
-						<td></td>
-						<td></td>
-						{Object.values(schema.acl.roles).map(role => <td class={'px-2'}>
-							<SinglePermission value={'D'}
-											  predicate={role.entities[entity.name]?.operations.delete} />
-						</td>)}
-					</tr>
-					{Object.values(entity.fields).map(field => (
-						<tr class={'even:bg-gray-100 target:bg-yellow-100'}
-							id={formatFieldAnchor(entity.name, field.name)}>
-							<td class={'px-2 font-mono truncate  w-[180px] max-w-[180px]'} title={field.name}>
-								{field.name}
-							</td>
-							<td class={'text-gray-800 px-2 font-mono w-[420px] max-w-[420px]'}>
-								<FieldType field={field} />
-							</td>
-							{Object.values(schema.acl.roles).map(role => <td class={'px-2'}>
-								<FieldPermissions field={field.name}
-												  entityPermissions={role.entities[entity.name]} />
-							</td>)}
-						</tr>
-					))}
-
-				</table>
-			</div>
-			<div class={'px-2 py-2 w-1/2'}>
-				<h3 class={'text-lg text-gray-600'}>On delete behaviour:</h3>
-				<p class={'text-gray-500 text-sm'}>
-					(What happens when you attempt to delete entity {entity.name})</p>
-				<div class={'mt-2 text-sm '}>
-					<OnDelete references={references} entity={entity} />
-				</div>
-			</div>
-			{false && <div class={'px-2 py-2 w-1/2'}>
-				<h3 class={'text-lg text-gray-600'}>ACL predicates:</h3>
-				<div class={'mt-2 text-sm '}>
-					{Object.entries(schema.acl.roles).map(([roleName, role]) =>
-						Object.entries(role.entities[entity.name]?.predicates ?? {}).map(([predicateName, predicate]) => (
-							<Fragment>
-								<h4>{roleName}: {predicateName}</h4>
-								<code>{JSON.stringify(predicate)}</code>
-							</Fragment>
-						)),
-					)}
-				</div>
-			</div>}
-		</div>
-	</div>
-)

package/src/utils/project/components/OnDelete.tsx

@@ -1,72 +0,0 @@
-import { h, Fragment } from 'preact'
-import { Model } from '@contember/schema'
-import { ReferenceMapEntry, ReferencesMap } from '../../schema/collectReferences'
-import { FieldLink } from './FieldLink'
-import { EntityLink } from './EntityLink'
-
-const sortReferences = (a: ReferenceMapEntry, b: ReferenceMapEntry) =>
-	a.owningRelation.joiningColumn.onDelete.localeCompare(b.owningRelation.joiningColumn.onDelete)
-	|| a.owningEntity.name.localeCompare(b.owningEntity.name)
-	|| a.owningRelation.name.localeCompare(b.owningRelation.name)
-
-export const OnDelete = ({ references, entity, visited = [] }: { references: ReferencesMap; entity: Model.Entity; visited?: Model.Entity[] }) => {
-	const referencedFrom = references[entity.name]
-	if (referencedFrom.length === 0) {
-		if (visited.length !== 0) {
-			return null
-		}
-		return (
-			<span class={'bg-green-200 text-gray-600 p-1 rounded'}>
-				This entity is not referenced from any other entity.
-			</span>
-		)
-	}
-
-	if (visited.includes(entity)) {
-		return (
-			<ul class={'ml-4'}>
-				<li class={'italic'}>(recursion)</li>
-			</ul>
-		)
-	}
-
-	return (
-		<ul class={visited.length > 0 ? 'ml-4' : ''}>
-			{referencedFrom
-				.sort(sortReferences)
-				.map(it => {
-					const inverseDescr = it.targetRelation
-						? <>see <FieldLink entity={entity.name} field={it.targetRelation.name} /></>
-						: 'no inverse side'
-					if (it.owningRelation.joiningColumn.onDelete === 'restrict') {
-						return (
-							<li>
-								<span class={'bg-black text-white px-1'}>Fails</span> when referenced from
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} />
-								{' '}({inverseDescr})
-							</li>
-						)
-					}
-					if (it.owningRelation.joiningColumn.onDelete === 'set null') {
-						return (
-							<li>
-								<span class={'bg-blue-400 text-white px-1'}>Sets null</span> at
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} />
-								{' '}({inverseDescr})
-							</li>
-						)
-					}
-					if (it.owningRelation.joiningColumn.onDelete === 'cascade') {
-						return (
-							<li>
-								<span class={'bg-red-400 text-white px-1'}>Deletes</span> <EntityLink entity={it.owningEntity.name} />
-								{' '}connected using
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} noEntityLabel />
-								{' '}({inverseDescr})
-								<OnDelete entity={it.owningEntity} visited={[...visited, entity]} references={references} />
-							</li>
-						)
-					}
-				})}
-		</ul>)
-}

package/src/utils/project/components/ProjectInfo.tsx

@@ -1,48 +0,0 @@
-import { Schema } from '@contember/schema'
-import { h } from 'preact'
-import { collectReferences } from '../../schema/collectReferences'
-import { EntityLink } from './EntityLink'
-import { EntityInfo } from './EntityInfo'
-
-
-export const ProjectInfo = (props: { schema: Schema; projectName: string }) => {
-	const references = collectReferences(props.schema.model)
-
-	return (
-		<div class={'w-full'}>
-			<div class={'bg-gray-100 p-6 border-b border-gray-400'}>
-				<h1 class={'font-bold text-xl mb-1'}>{props.projectName}</h1>
-				<div class={'flex flex-column gap-4'}>
-					<div>
-						<h2 class={'font-semibold text-gray-500 mb-1'}>Entities</h2>
-						<ul class={'text-sm'}>
-							{Object.values(props.schema.model.entities).map(entity => (
-								<li>
-									<EntityLink entity={entity.name} />
-								</li>
-							))}
-						</ul>
-					</div>
-					<div>
-						<h2 class={'font-semibold text-gray-500 mb-1'}>Enums</h2>
-						<ul class={'text-sm'}>
-							{Object.entries(props.schema.model.enums).map(([name, values]) => (
-								<li class={'mb-2'}>
-									{name} <br />
-									<span class={'text-gray-700 ml-4'}>
-										{values.join(', ')}
-									</span>
-								</li>
-							))}
-						</ul>
-					</div>
-				</div>
-
-
-			</div>
-			{Object.values(props.schema.model.entities).map(entity => (
-				<EntityInfo entity={entity} schema={props.schema} references={references}/>
-			))}
-		</div>
-	)
-}

package/src/utils/project/loadSchema.ts

@@ -1,14 +0,0 @@
-import { Project } from '@contember/cli-common'
-import { Schema } from '@contember/schema'
-import { join } from 'node:path'
-import { schemaType } from '@contember/schema-utils'
-import { buildJs } from '../esbuild'
-
-export const loadSchema = async (project: Project): Promise<Schema> => {
-	const bundledJs = await buildJs(join(project.apiDir, 'index.ts'))
-
-	const fn = new Function('require', `var module = {}; ((module) => { ${bundledJs} })(module); return module`)
-
-	const schema = fn(require).exports.default
-	return schemaType(schema)
-}

package/src/utils/project/projectDescribe.tsx

@@ -1,26 +0,0 @@
-import { Schema } from '@contember/schema'
-import { h } from 'preact'
-import render from 'preact-render-to-string'
-import { ProjectInfo } from './components/ProjectInfo'
-import { readFile } from 'node:fs/promises'
-
-export const renderProjectInfoHtml = async (schema: Schema, projectName: string) => {
-	const html = render(<ProjectInfo schema={schema} projectName={projectName} />)
-
-	const css = await readFile(__dirname + '/resources/out.css')
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<style>${css}</style>
-	<title>${projectName}</title>
-</head>
-<body>
-${html}
-</body>
-</html>
-`
-
-}
-

package/src/utils/schema.ts

@@ -1,19 +0,0 @@
-import { SchemaValidator, SchemaValidatorSkippedErrors, ValidationError } from '@contember/schema-utils'
-import { Schema } from '@contember/schema'
-
-export const printValidationErrors = (errors: ValidationError[], message?: string) => {
-	if (errors.length === 0) {
-		return
-	}
-	console.group(message || 'Schema is invalid:')
-	for (const err of errors) {
-		console.log(`${err.path.join('.')}: [${err.code}] ${err.message}`)
-	}
-	console.groupEnd()
-}
-
-export const validateSchemaAndPrintErrors = (schema: Schema, message?: string, skippedErrors?: SchemaValidatorSkippedErrors[]): boolean => {
-	const errors = SchemaValidator.validate(schema, skippedErrors)
-	printValidationErrors(errors, message)
-	return errors.length === 0
-}