@contember/schema-migrations 2.1.0-alpha.9 → 2.1.0-beta.2

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, "''")
 }

package/tests/cases/integration/convertOneToManyRelation.test.ts

@@ -9,17 +9,13 @@ describe('convert one has one to many has one relation', () => {
 	testMigrations({
 		original: {
 			model: new SchemaBuilder()
-				.entity('Post', entity =>
-					entity.oneHasOne('image', rel => rel.target('Image')),
-				)
+				.entity('Post', entity => entity.oneHasOne('image', rel => rel.target('Image')))
 				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
 				.buildSchema(),
 		},
 		updated: {
 			model: new SchemaBuilder()
-				.entity('Post', entity =>
-					entity.manyHasOne('image', rel => rel.target('Image')),
-				)
+				.entity('Post', entity => entity.manyHasOne('image', rel => rel.target('Image')))
 				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
 				.buildSchema(),
 		},
@@ -49,88 +45,80 @@ describe('convert one has one to many has one relation', () => {
 	})
 })
 
-
-describe('convert one has one to many has one relation with inverse side', () => testMigrations({
-	original: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.oneHasOne('image', rel => rel.target('Image').inversedBy('post')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'convertOneToManyRelation',
-			entityName: 'Post',
-			fieldName: 'image',
-			newInverseSideFieldName: 'posts',
+describe('convert one has one to many has one relation with inverse side', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Post', entity => entity.oneHasOne('image', rel => rel.target('Image').inversedBy('post')))
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL`
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Post', entity => entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')))
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
+		},
+		diff: [
+			{
+				modification: 'convertOneToManyRelation',
+				entityName: 'Post',
+				fieldName: 'image',
+				newInverseSideFieldName: 'posts',
+			},
+		],
+		sql: SQL`
 	CREATE INDEX ON "post" ("image_id"); 
 	ALTER TABLE "post" DROP CONSTRAINT "uniq_post_image_id";
 `,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [],
-		indexes: [],
-		uniqueConstraints: [{
-			constraintName: 'uniq_post_image_id',
-			columnNames: ['image_id'],
-			tableName: 'post',
-			deferred: false,
-			deferrable: false,
-		}],
-	}),
-}))
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [],
+			uniqueConstraints: [{
+				constraintName: 'uniq_post_image_id',
+				columnNames: ['image_id'],
+				tableName: 'post',
+				deferred: false,
+				deferrable: false,
+			}],
+		}),
+	}))
 
-describe('convert one has one to many has one relation with inverse side, but not renamed', () => testMigrations({
-	original: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.oneHasOne('image', rel => rel.target('Image').inversedBy('posts')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'convertOneToManyRelation',
-			entityName: 'Post',
-			fieldName: 'image',
+describe('convert one has one to many has one relation with inverse side, but not renamed', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Post', entity => entity.oneHasOne('image', rel => rel.target('Image').inversedBy('posts')))
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL`
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Post', entity => entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')))
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
+		},
+		diff: [
+			{
+				modification: 'convertOneToManyRelation',
+				entityName: 'Post',
+				fieldName: 'image',
+			},
+		],
+		sql: SQL`
         CREATE INDEX ON "post" ("image_id");
         ALTER TABLE "post"
             DROP CONSTRAINT "uniq_post_image_id";
 	`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [],
-		indexes: [],
-		uniqueConstraints: [{
-			constraintName: 'uniq_post_image_id',
-			columnNames: ['image_id'],
-			tableName: 'post',
-			deferred: false,
-			deferrable: false,
-		}],
-	}),
-}))
-
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [],
+			uniqueConstraints: [{
+				constraintName: 'uniq_post_image_id',
+				columnNames: ['image_id'],
+				tableName: 'post',
+				deferred: false,
+				deferrable: false,
+			}],
+		}),
+	}))