@contember/schema-migrations 2.1.0-alpha.30 → 2.1.0-alpha.36

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -1,12 +1,7 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import {
-	createModificationType,
-	Differ,
-	ModificationHandler,
-	ModificationHandlerCreateSqlOptions,
-} from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { updateRelations } from '../utils/diffUtils'
 import { acceptRelationTypeVisitor } from '@contember/schema-utils'
@@ -72,10 +67,10 @@ export class UpdateRelationOnDeleteDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				originalRelation.type === updatedRelation.type &&
-				isIt<Model.JoiningColumnRelation>(updatedRelation, 'joiningColumn') &&
-				isIt<Model.JoiningColumnRelation>(originalRelation, 'joiningColumn') &&
-				updatedRelation.joiningColumn.onDelete !== originalRelation.joiningColumn.onDelete
+				originalRelation.type === updatedRelation.type
+				&& isIt<Model.JoiningColumnRelation>(updatedRelation, 'joiningColumn')
+				&& isIt<Model.JoiningColumnRelation>(originalRelation, 'joiningColumn')
+				&& updatedRelation.joiningColumn.onDelete !== originalRelation.joiningColumn.onDelete
 			) {
 				return updateRelationOnDeleteModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/UpdateRelationOrderByModification.ts

@@ -5,7 +5,6 @@ import deepEqual from 'fast-deep-equal'
 import { updateRelations } from '../utils/diffUtils'
 
 export class UpdateRelationOrderByModificationHandler implements ModificationHandler<UpdateRelationOrderByModificationData> {
-
 	constructor(private readonly data: UpdateRelationOrderByModificationData, private readonly schema: Schema) {}
 
 	public createSql(): void {}
@@ -45,10 +44,10 @@ export class UpdateRelationOrderByDiffer implements Differ {
 			const isItOrderable = (relation: Model.AnyRelation): relation is Model.OrderableRelation & Model.AnyRelation =>
 				relation.type === Model.RelationType.ManyHasMany || relation.type === Model.RelationType.OneHasMany
 			if (
-				updatedRelation.type === originalRelation.type &&
-				isItOrderable(updatedRelation) &&
-				isItOrderable(originalRelation) &&
-				!deepEqual(updatedRelation.orderBy || [], originalRelation.orderBy || [])
+				updatedRelation.type === originalRelation.type
+				&& isItOrderable(updatedRelation)
+				&& isItOrderable(originalRelation)
+				&& !deepEqual(updatedRelation.orderBy || [], originalRelation.orderBy || [])
 			) {
 				return updateRelationOrderByModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/helpers.ts

@@ -33,7 +33,9 @@ export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntit
 	} as const)[relation.joiningColumn.onDelete]
 	builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)}
 		ADD FOREIGN KEY (${wrapIdentifier(relation.joiningColumn.columnName)}) 
-		REFERENCES ${wrapIdentifier(targetEntity.tableName)}(${wrapIdentifier(targetEntity.primaryColumn)}) ON DELETE ${onDelete} DEFERRABLE INITIALLY IMMEDIATE`)
+		REFERENCES ${wrapIdentifier(targetEntity.tableName)}(${
+		wrapIdentifier(targetEntity.primaryColumn)
+	}) ON DELETE ${onDelete} DEFERRABLE INITIALLY IMMEDIATE`)
 
 	invalidateDatabaseMetadata()
 }

package/src/modifications/settings/UpdateSettingsModification.ts

@@ -28,11 +28,9 @@ export class UpdateSettingsModificationHandler implements ModificationHandler<Up
 		}
 	}
 
-
 	describe() {
 		return { message: `Change settings of ${this.data.key}` }
 	}
-
 }
 
 export const updateSettingsModification = createModificationType({
@@ -42,10 +40,12 @@ export const updateSettingsModification = createModificationType({
 
 export class UpdateSettingsDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		const allKeys = Array.from(new Set([
-			...Object.keys(originalSchema.settings),
-			...Object.keys(updatedSchema.settings),
-		] as (keyof Settings.Schema)[]))
+		const allKeys = Array.from(
+			new Set([
+				...Object.keys(originalSchema.settings),
+				...Object.keys(updatedSchema.settings),
+			] as (keyof Settings.Schema)[]),
+		)
 
 		return allKeys
 			.filter(key => !deepEqual(originalSchema.settings[key], updatedSchema.settings[key]))
@@ -66,21 +66,17 @@ export class UpdateSettingsDiffer implements Differ {
 	}
 }
 
-
-
 export interface SetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
 	op: 'set'
 	key: K
 	value: Settings.Schema[K]
 }
 
-
 export interface UnsetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
 	op: 'unset'
 	key: K
 }
 
-
 export type UpdateSettingsModificationData =
 	| SetSettingsModificationData
 	| UnsetSettingsModificationData

package/src/modifications/upgrade/RemoveIndexNamesModification.ts

@@ -2,9 +2,7 @@ import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateEveryEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 
-export class RemoveIndexNamesModificationHandler implements ModificationHandler<RemoveIndexNamesModificationData>  {
-	constructor() {}
-
+export class RemoveIndexNamesModificationHandler implements ModificationHandler<RemoveIndexNamesModificationData> {
 	public createSql(): void {
 	}
 
@@ -36,7 +34,6 @@ export const removeIndexNamesModification = createModificationType({
 	handler: RemoveIndexNamesModificationHandler,
 })
 
-
 export type RemoveIndexNamesModificationData = {}
 
 export class RemoveIndexNamesDiffer implements Differ {

package/src/modifications/utils/columnUtils.ts

@@ -3,6 +3,5 @@ import { Model } from '@contember/schema'
 export const getColumnSqlType = (column: Pick<Model.AnyColumn, 'type' | 'columnType' | 'list'>) =>
 	(column.type === Model.ColumnType.Enum
 		? `"${column.columnType}"`
-		: column.columnType
-	)
+		: column.columnType)
 	+ (column.list ? '[]' : '')

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -4,7 +4,6 @@ import { isDefined } from '../../utils/isDefined'
 import { isInverseRelation, isOwningRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
 
-
 export type SchemaUpdater = (args: { schema: Schema }) => Schema
 export type ModelUpdater = (args: { schema: Schema; model: Model.Schema }) => Model.Schema
 export type EntityUpdater = (args: { schema: Schema; model: Model.Schema; entity: Model.Entity }) => Model.Entity
@@ -46,57 +45,47 @@ export type EntityAclEveryPredicatesUpdater = (args: {
 	predicate: Acl.PredicateDefinition
 }) => Acl.PredicateDefinition
 
-export const updateSchema =
-	(...schemaUpdater: (SchemaUpdater | undefined)[]): SchemaUpdater =>
-		args =>
-			schemaUpdater.filter(isDefined).reduce((schema, updater) => updater({ ...args, schema }), args.schema)
+export const updateSchema = (...schemaUpdater: (SchemaUpdater | undefined)[]): SchemaUpdater => args =>
+	schemaUpdater.filter(isDefined).reduce((schema, updater) => updater({ ...args, schema }), args.schema)
 
-export const updateAcl =
-	(updater: AclUpdater): SchemaUpdater =>
-		args => ({
-			...args.schema,
-			acl: updater({ schema: args.schema, acl: args.schema.acl }),
-		})
+export const updateAcl = (updater: AclUpdater): SchemaUpdater => args => ({
+	...args.schema,
+	acl: updater({ schema: args.schema, acl: args.schema.acl }),
+})
 
-export const updateAclEveryRole =
-	(...updater: AclRoleUpdater[]): AclUpdater =>
-		args => ({
-			...args.acl,
-			roles: Object.fromEntries(
-				updater.reduce(
-					(acc, updater) => acc.map(([name, role]) => [name, updater({ ...args, role })]),
-					Object.entries(args.acl.roles),
-				),
-			),
-		})
+export const updateAclEveryRole = (...updater: AclRoleUpdater[]): AclUpdater => args => ({
+	...args.acl,
+	roles: Object.fromEntries(
+		updater.reduce(
+			(acc, updater) => acc.map(([name, role]) => [name, updater({ ...args, role })]),
+			Object.entries(args.acl.roles),
+		),
+	),
+})
 
-export const updateAclEntities =
-	(updater: AclPermissionsUpdater): AclRoleUpdater =>
-		args => ({
-			...args.role,
-			entities: updater({ ...args, entities: args.role.entities }),
-		})
+export const updateAclEntities = (updater: AclPermissionsUpdater): AclRoleUpdater => args => ({
+	...args.role,
+	entities: updater({ ...args, entities: args.role.entities }),
+})
 
-export const updateAclEveryEntity =
-	(...updater: AclEntityPermissionsUpdater[]): AclRoleUpdater =>
-		args => ({
-			...args.role,
-			entities: Object.fromEntries(
-				updater.reduce(
-					(acc, updater) =>
-						acc.map(([entity, entityPermissions]) => [
-							entity,
-							updater({
-								...args,
-								entities: args.role.entities,
-								entityName: entity,
-								entityPermissions,
-							}),
-						]),
-					Object.entries(args.role.entities),
-				),
-			),
-		})
+export const updateAclEveryEntity = (...updater: AclEntityPermissionsUpdater[]): AclRoleUpdater => args => ({
+	...args.role,
+	entities: Object.fromEntries(
+		updater.reduce(
+			(acc, updater) =>
+				acc.map(([entity, entityPermissions]) => [
+					entity,
+					updater({
+						...args,
+						entities: args.role.entities,
+						entityName: entity,
+						entityPermissions,
+					}),
+				]),
+			Object.entries(args.role.entities),
+		),
+	),
+})
 
 type EntityAclFieldPermissionsUpdater = (
 	fieldPermissions: Acl.FieldPermissions,
@@ -110,127 +99,114 @@ type EntityOperationHandler = {
 }
 
 export const updateAclFieldPermissions =
-	(updater: EntityAclFieldPermissionsUpdater): AclEntityPermissionsUpdater =>
-		({ entityPermissions, entityName }) => {
-			const operations: Writable<Acl.EntityOperations> = {}
-			const handlers: EntityOperationHandler = {
-				create: value => updater(value, entityName, Acl.Operation.create),
-				update: value => updater(value, entityName, Acl.Operation.update),
-				read: value => updater(value, entityName, Acl.Operation.read),
-				delete: value => value,
-				customPrimary: value => value,
-				refreshMaterializedView: value => value,
-				noRoot: value => value,
-			}
-			const types: (keyof Acl.EntityOperations)[] = ['create', 'update', 'read', 'delete', 'customPrimary', 'noRoot']
-			for (const key of types) {
-				if (key in entityPermissions.operations) {
-					operations[key] = handlers[key](entityPermissions.operations[key] as any) as any
-				}
-			}
-
-			return {
-				...entityPermissions,
-				operations,
+	(updater: EntityAclFieldPermissionsUpdater): AclEntityPermissionsUpdater => ({ entityPermissions, entityName }) => {
+		const operations: Writable<Acl.EntityOperations> = {}
+		const handlers: EntityOperationHandler = {
+			create: value => updater(value, entityName, Acl.Operation.create),
+			update: value => updater(value, entityName, Acl.Operation.update),
+			read: value => updater(value, entityName, Acl.Operation.read),
+			delete: value => value,
+			customPrimary: value => value,
+			refreshMaterializedView: value => value,
+			noRoot: value => value,
+		}
+		const types: (keyof Acl.EntityOperations)[] = ['create', 'update', 'read', 'delete', 'customPrimary', 'noRoot']
+		for (const key of types) {
+			if (key in entityPermissions.operations) {
+				operations[key] = handlers[key](entityPermissions.operations[key] as any) as any
 			}
 		}
 
-export const updateAclEveryPredicate =
-	(updater: EntityAclEveryPredicatesUpdater): AclEntityPermissionsUpdater =>
-		args => {
-			return {
-				...args.entityPermissions,
-				predicates: Object.fromEntries(
-					Object.entries(args.entityPermissions.predicates).map(([name, predicate]) => [
-						name,
-						updater({
-							...args,
-							predicate,
-						}),
-					]),
-				),
-			}
+		return {
+			...entityPermissions,
+			operations,
 		}
+	}
 
-export const updateModel =
-	(...modelUpdate: (ModelUpdater | undefined)[]): SchemaUpdater =>
-		args => ({
-			...args.schema,
-			model: modelUpdate
-				.filter((it): it is ModelUpdater => it !== undefined)
-				.reduce((model, updater) => updater({ ...args, model }), args.schema.model),
-		})
+export const updateAclEveryPredicate = (updater: EntityAclEveryPredicatesUpdater): AclEntityPermissionsUpdater => args => {
+	return {
+		...args.entityPermissions,
+		predicates: Object.fromEntries(
+			Object.entries(args.entityPermissions.predicates).map(([name, predicate]) => [
+				name,
+				updater({
+					...args,
+					predicate,
+				}),
+			]),
+		),
+	}
+}
 
-export const updateEntity =
-	(name: string, entityUpdate: EntityUpdater): ModelUpdater =>
-		args => {
-			if (!args.model.entities[name]) {
-				throw new SchemaUpdateError(`Entity ${name} not found`)
-			}
-			return {
-				...args.model,
-				entities: {
-					...args.model.entities,
-					[name]: entityUpdate({ ...args, entity: args.model.entities[name] }),
-				},
-			}
-		}
+export const updateModel = (...modelUpdate: (ModelUpdater | undefined)[]): SchemaUpdater => args => ({
+	...args.schema,
+	model: modelUpdate
+		.filter((it): it is ModelUpdater => it !== undefined)
+		.reduce((model, updater) => updater({ ...args, model }), args.schema.model),
+})
 
-export const updateEveryEntity =
-	(entityUpdate: EntityUpdater): ModelUpdater =>
-		args => ({
-			...args.model,
-			entities: Object.fromEntries(
-				Object.entries(args.model.entities).map(([name, entity]) => [name, entityUpdate({ ...args, entity })]),
-			),
-		})
+export const updateEntity = (name: string, entityUpdate: EntityUpdater): ModelUpdater => args => {
+	if (!args.model.entities[name]) {
+		throw new SchemaUpdateError(`Entity ${name} not found`)
+	}
+	return {
+		...args.model,
+		entities: {
+			...args.model.entities,
+			[name]: entityUpdate({ ...args, entity: args.model.entities[name] }),
+		},
+	}
+}
+
+export const updateEveryEntity = (entityUpdate: EntityUpdater): ModelUpdater => args => ({
+	...args.model,
+	entities: Object.fromEntries(
+		Object.entries(args.model.entities).map(([name, entity]) => [name, entityUpdate({ ...args, entity })]),
+	),
+})
 
 export const updateField =
 	<In extends Model.AnyField = Model.AnyField, Out extends Model.AnyField = In>(name: string, fieldUpdater: FieldUpdater<In, Out>): EntityUpdater =>
-		args => {
-			const { [name]: field, ...otherFields } = args.entity.fields
-			if (!args.entity.fields[name]) {
-				throw new SchemaUpdateError(`Field ${args.entity.name}::${name} not found`)
-			}
-			const updatedField = fieldUpdater({ ...args, field: args.entity.fields[name] as In })
-
-			return {
-				...args.entity,
-				fields: {
-					...otherFields,
-					...(updatedField ? { [name]: updatedField } : {}),
-				},
-			}
+	args => {
+		const { [name]: field, ...otherFields } = args.entity.fields
+		if (!args.entity.fields[name]) {
+			throw new SchemaUpdateError(`Field ${args.entity.name}::${name} not found`)
 		}
+		const updatedField = fieldUpdater({ ...args, field: args.entity.fields[name] as In })
 
-export const updateEveryField =
-	(fieldUpdater: FieldUpdater<Model.AnyField, Model.AnyField>): EntityUpdater =>
-		args => ({
+		return {
 			...args.entity,
-			fields: Object.fromEntries(
-				Object.entries(args.entity.fields)
-					.map(([name, field]) => {
-						const updatedField = fieldUpdater({ ...args, field })
-						if (!updatedField) {
-							return undefined
-						}
-						return [name, updatedField]
-					})
-					.filter(isDefined),
-			),
-		})
-
-export const addField =
-	(field: Model.AnyField): EntityUpdater =>
-		args => {
-			return {
-				...args.entity,
-				fields: {
-					...args.entity.fields,
-					[field.name]: field,
-				},
-			}
+			fields: {
+				...otherFields,
+				...(updatedField ? { [name]: updatedField } : {}),
+			},
 		}
+	}
+
+export const updateEveryField = (fieldUpdater: FieldUpdater<Model.AnyField, Model.AnyField>): EntityUpdater => args => ({
+	...args.entity,
+	fields: Object.fromEntries(
+		Object.entries(args.entity.fields)
+			.map(([name, field]) => {
+				const updatedField = fieldUpdater({ ...args, field })
+				if (!updatedField) {
+					return undefined
+				}
+				return [name, updatedField]
+			})
+			.filter(isDefined),
+	),
+})
+
+export const addField = (field: Model.AnyField): EntityUpdater => args => {
+	return {
+		...args.entity,
+		fields: {
+			...args.entity.fields,
+			[field.name]: field,
+		},
+	}
+}
 
 export const removeField = (entityName: string, fieldName: string, version: number): SchemaUpdater => {
 	return ({ schema }) => {
@@ -253,20 +229,18 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 							updateAclEveryPredicate(({ predicate, entityName }) => {
 								const processor = new PredicateDefinitionProcessor(schema.model)
 								return processor.process(schema.model.entities[entityName], predicate, {
-									handleColumn: ctx =>
-										ctx.entity.name === entity.name && ctx.column.name === field.name ? undefined : ctx.value,
-									handleRelation: ctx =>
-										ctx.entity.name === entity.name && ctx.relation.name === field.name ? undefined : ctx.value,
+									handleColumn: ctx => ctx.entity.name === entity.name && ctx.column.name === field.name ? undefined : ctx.value,
+									handleRelation: ctx => ctx.entity.name === entity.name && ctx.relation.name === field.name ? undefined : ctx.value,
 								})
 							}),
 						),
 					),
-				  )
+				)
 				: undefined,
-			isRelation(field) &&
-				isOwningRelation(field) &&
-				field.inversedBy &&
-				version >= VERSION_REMOVE_RELATION_INVERSE_SIDE
+			isRelation(field)
+				&& isOwningRelation(field)
+				&& field.inversedBy
+				&& version >= VERSION_REMOVE_RELATION_INVERSE_SIDE
 				? removeField(field.target, field.inversedBy, version)
 				: undefined,
 			updateModel(
@@ -285,7 +259,7 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 					? updateEntity(
 						field.target,
 						updateField<Model.AnyOwningRelation>(field.ownedBy, ({ field: { inversedBy, ...field } }) => field),
-					  )
+					)
 					: undefined,
 			),
 		)({ schema })

package/src/modifications/utils/valueUtils.ts

@@ -1,4 +1 @@
-export const changeValue =
-	(from: string, to: string) =>
-		(value: string): string =>
-			value === from ? to : value
+export const changeValue = (from: string, to: string) => (value: string): string => value === from ? to : value

package/src/modifications/validation/UpdateValidationSchemaModification.ts

@@ -20,7 +20,6 @@ export class UpdateValidationSchemaModificationHandler implements ModificationHa
 	describe() {
 		return { message: 'Update validation schema' }
 	}
-
 }
 
 export interface UpdateValidationSchemaModificationData {

package/src/tsconfig.json

@@ -2,8 +2,7 @@
 	"extends": "../tsconfig.settings.json",
 	"compilerOptions": {
 		"outDir": "../dist/types",
-		"esModuleInterop": true,
-		"downlevelIteration": true
+		"esModuleInterop": true
 	},
 	"references": [
 		{ "path": "../../database-migrations/src" },

package/src/utils/PartialEntity.ts

@@ -6,6 +6,6 @@ export type PossibleEntityShapeInMigrations =
 	& Omit<Model.Entity, 'eventLog' | 'indexes' | 'unique'>
 	& {
 		eventLog?: Model.Entity['eventLog']
-		indexes?: (readonly  Model.Index[]) | Readonly<Record<string, Model.Index>>
-		unique: (readonly  (Model.UniqueConstraint | Model.UniqueIndex)[]) | Readonly<Record<string, Model.UniqueConstraint>>
+		indexes?: (readonly Model.Index[]) | Readonly<Record<string, Model.Index>>
+		unique: (readonly (Model.UniqueConstraint | Model.UniqueIndex)[]) | Readonly<Record<string, Model.UniqueConstraint>>
 	}

package/src/utils/escapeSqlString.ts

@@ -1,3 +1,3 @@
 export function escapeSqlString(src: string) {
-	return src.replace(/\\/g, '\\\\').replace(/\'/g, "''")
+	return src.replace(/\\/g, '\\\\').replace(/'/g, "''")
 }