@contember/schema-migrations 2.0.0-alpha.19 → 2.0.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.0.0-alpha.19",
+  "version": "2.0.0-alpha.21",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,16 +23,16 @@
     }
   },
   "dependencies": {
-    "@contember/database": "2.0.0-alpha.19",
-    "@contember/database-migrations": "2.0.0-alpha.19",
-    "@contember/engine-common": "2.0.0-alpha.19",
-    "@contember/schema": "2.0.0-alpha.19",
-    "@contember/schema-utils": "2.0.0-alpha.19",
+    "@contember/database": "2.0.0-alpha.21",
+    "@contember/database-migrations": "2.0.0-alpha.21",
+    "@contember/engine-common": "2.0.0-alpha.21",
+    "@contember/schema": "2.0.0-alpha.21",
+    "@contember/schema-utils": "2.0.0-alpha.21",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.1.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.0.0-alpha.19"
+    "@contember/schema-definition": "2.0.0-alpha.21"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/modifications/columns/columnUtils.ts

@@ -36,7 +36,7 @@ export const formatSeedExpression = ({ model, entity, columnType, fillValue, cop
 	copyValue?: string
 }): string | null => {
 	if (fillValue !== undefined) {
-		return escapeValue(fillValue)
+		return escapeValue(fillValue).toString()
 	} else if (copyValue !== undefined) {
 		const copyFrom = getColumnName(model, entity, copyValue)
 		return `${wrapIdentifier(copyFrom)}::${columnType}`

package/src/modifications/entities/RemoveEntityModification.ts

@@ -1,5 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Acl, Schema } from '@contember/schema'
+import { Acl, Model, Schema } from '@contember/schema'
 import {
 	removeField,
 	SchemaUpdater,
@@ -18,7 +18,7 @@ import {
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_REFERENCING_RELATIONS } from '../ModificationVersions'
-import { isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, isInverseRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { removeFieldModification } from '../fields'
 
 export class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
@@ -40,6 +40,17 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 				removeFieldHandler.createSql(builder, options)
 			})
 		}
+		acceptEveryFieldVisitor(this.schema.model, entity, {
+			visitManyHasManyOwning: ({ relation }) => {
+				builder.dropTable(relation.joiningTable.tableName)
+			},
+			visitManyHasManyInverse: () => {},
+			visitColumn: () => {},
+			visitOneHasOneInverse: () => {},
+			visitOneHasOneOwning: () => {},
+			visitManyHasOne: () => {},
+			visitOneHasMany: () => {},
+		})
 		builder.dropTable(entity.tableName)
 	}
 
@@ -99,7 +110,8 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 	private getFieldsToRemove(schema: Schema): [entity: string, field: string][] {
 		return Object.values(schema.model.entities).flatMap(entity =>
 			Object.values(entity.fields)
-				.filter(field => isRelation(field) && field.target === this.data.entityName)
+				.filter((field): field is Model.AnyRelation => isRelation(field) && field.target === this.data.entityName)
+				.filter(field => !isInverseRelation(field) || entity.name !== this.data.entityName) // skip self-referencing inverse relations
 				.map((field): [string, string] => [entity.name, field.name]),
 		)
 	}

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

@@ -79,6 +79,10 @@ testMigrations('create a column with default value with "using"', {
 	updated: createSchema({
 		Author: class Author {
 			name = def.stringColumn().default('unnamed author').notNull()
+			order = def.intColumn().default(0).notNull()
+			score = def.doubleColumn().default(1 / 3).notNull()
+			active = def.boolColumn().default(false).notNull()
+			createdAt = def.dateTimeColumn().default('2024-01-01 10:00').notNull()
 			email = def.stringColumn().unique()
 		},
 	}),
@@ -97,7 +101,73 @@ testMigrations('create a column with default value with "using"', {
 			fillValue: 'unnamed author',
 			valueMigrationStrategy: 'using',
 		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'order',
+				name: 'order',
+				nullable: false,
+				default: 0,
+				type: Model.ColumnType.Int,
+				columnType: 'integer',
+			},
+			fillValue: 0,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'score',
+				name: 'score',
+				nullable: false,
+				default: 0.3333333333333333,
+				type: Model.ColumnType.Double,
+				columnType: 'double precision',
+			},
+			fillValue: 0.3333333333333333,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'active',
+				name: 'active',
+				nullable: false,
+				default: false,
+				type: Model.ColumnType.Bool,
+				columnType: 'boolean',
+			},
+			fillValue: false,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'created_at',
+				name: 'createdAt',
+				nullable: false,
+				default: '2024-01-01 10:00',
+				type: Model.ColumnType.DateTime,
+				columnType: 'timestamptz',
+			},
+			fillValue: '2024-01-01 10:00',
+			valueMigrationStrategy: 'using',
+		},
 	],
-	sql: SQL`ALTER TABLE "author" ADD "name" text;
-ALTER TABLE "author" ALTER "name" SET DATA TYPE text USING $pga$unnamed author$pga$, ALTER "name" SET NOT NULL;`,
+	sql: SQL`
+ALTER TABLE "author" ADD "name" text;
+ALTER TABLE "author" ALTER "name" SET DATA TYPE text USING $pga$unnamed author$pga$, ALTER "name" SET NOT NULL;
+ALTER TABLE "author" ADD "order" integer;
+ALTER TABLE "author" ALTER "order" SET DATA TYPE integer USING 0, ALTER "order" SET NOT NULL;
+ALTER TABLE "author" ADD "score" double precision;
+ALTER TABLE "author" ALTER "score" SET DATA TYPE double precision USING 0.3333333333333333, ALTER "score" SET NOT NULL;
+ALTER TABLE "author" ADD "active" boolean; 
+ALTER TABLE "author" ALTER "active" SET DATA TYPE boolean USING false, 
+ALTER "active" SET NOT NULL; ALTER TABLE "author" ADD "created_at" timestamptz; 
+ALTER TABLE "author" ALTER "created_at" SET DATA TYPE timestamptz USING $pga$2024-01-01 10:00$pga$, ALTER "created_at" SET NOT NULL;
+`,
 })

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

@@ -119,3 +119,99 @@ testMigrations('remove a view', {
 	sql: SQL`
 	DROP VIEW "author";`,
 })
+
+
+namespace EntityWithManyHasManyOriginalSchema {
+
+	export class Book {
+		title = def.stringColumn()
+		tags = def.manyHasMany(Tag, 'books')
+	}
+
+	export class Tag {
+		name = def.stringColumn()
+		books = def.manyHasManyInverse(Book, 'tags')
+	}
+}
+testMigrations('remove junction table, when both entities are removed', {
+	original: createSchema(EntityWithManyHasManyOriginalSchema),
+	updated: {},
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Book',
+		},
+		{
+			modification: 'removeEntity',
+			entityName: 'Tag',
+		},
+	],
+	sql: SQL`DROP TABLE "book_tags";
+DROP TABLE "book"; 
+DROP TABLE "tag";`,
+})
+
+
+namespace EntityWithManyHasManyUpdatedSchema {
+
+	export class Tag {
+		name = def.stringColumn()
+	}
+}
+testMigrations('remove junction table, when owning entity is removed', {
+	original: createSchema(EntityWithManyHasManyOriginalSchema),
+	updated: createSchema(EntityWithManyHasManyUpdatedSchema),
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Book',
+		},
+
+	],
+	sql: SQL`DROP TABLE "book_tags";
+DROP TABLE "book";`,
+})
+
+
+namespace EntityWithManyHasMany2UpdatedSchema {
+
+	export class Book {
+		title = def.stringColumn()
+	}
+}
+testMigrations('remove junction table, when inverse entity is removed', {
+	original: createSchema(EntityWithManyHasManyOriginalSchema),
+	updated: createSchema(EntityWithManyHasMany2UpdatedSchema),
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Tag',
+		},
+
+	],
+	sql: SQL`
+DROP TABLE "book_tags";
+DROP TABLE "tag";`,
+})
+
+
+namespace EntityWithSelfReferencingRelationOriginalSchema {
+
+	export class Person {
+		name = def.stringColumn()
+		parent = def.manyHasOne(Person, 'children')
+		children = def.oneHasMany(Person, 'parent')
+	}
+}
+
+testMigrations('remove self-referencing relation', {
+	original: createSchema(EntityWithSelfReferencingRelationOriginalSchema),
+	updated: {},
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Person',
+		},
+	],
+	sql: SQL`ALTER TABLE "person" DROP "parent_id"; DROP TABLE "person";`,
+})