@contember/schema-migrations 2.1.0-alpha.20 → 2.1.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.1.0-alpha.20",
+  "version": "2.1.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.1.0-alpha.20",
-    "@contember/database-migrations": "2.1.0-alpha.20",
-    "@contember/engine-common": "2.1.0-alpha.20",
-    "@contember/schema": "2.1.0-alpha.20",
-    "@contember/schema-utils": "2.1.0-alpha.20",
+    "@contember/database": "2.1.0-alpha.21",
+    "@contember/database-migrations": "2.1.0-alpha.21",
+    "@contember/engine-common": "2.1.0-alpha.21",
+    "@contember/schema": "2.1.0-alpha.21",
+    "@contember/schema-utils": "2.1.0-alpha.21",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.1.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.1.0-alpha.20"
+    "@contember/schema-definition": "2.1.0-alpha.21"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/modifications/enums/UpdateEnumModification.ts

@@ -1,20 +1,57 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Schema } from '@contember/schema'
+import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createCheck, getConstraintName } from './enumUtils'
+import { getColumnSqlType } from '../utils/columnUtils'
 
 export class UpdateEnumModificationHandler implements ModificationHandler<UpdateEnumModificationData> {
 	constructor(private readonly data: UpdateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		builder.sql(`
-			ALTER DOMAIN "${this.data.enumName}"
-			DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
-		builder.sql(`
-			ALTER DOMAIN "${this.data.enumName}"
-			ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
+		if (!this.requiresNewDomain()) {
+			builder.sql(`
+				ALTER DOMAIN "${this.data.enumName}"
+				DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
+			builder.sql(`
+				ALTER DOMAIN "${this.data.enumName}"
+				ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
+		} else {
+			/**
+			 * Because postgres does not support altering domain constrains
+			 * when used in composite types (like arrays) we need to:
+			 * - create a new domain with the new constraint
+			 * - update all the columns using the old domain to use the new domain
+			 * - drop the old domain and rename the new domain to the old name
+			 */
+			const oldName = `${this.data.enumName}__old`
+			builder.renameDomain(this.data.enumName, oldName)
+
+			builder.createDomain(this.data.enumName, 'text', {
+				check: createCheck(this.data.values),
+				constraintName: getConstraintName(this.data.enumName),
+			})
+			for (const entity of Object.values(this.schema.model.entities)) {
+				for (const field of Object.values(entity.fields)) {
+					if (field.type === Model.ColumnType.Enum && field.columnType === this.data.enumName) {
+						builder.alterColumn(entity.tableName, field.columnName, {
+							type: getColumnSqlType(field),
+						})
+					}
+				}
+			}
+
+			builder.dropDomain(oldName)
+		}
+	}
+
+	private requiresNewDomain(): boolean {
+		return Object.values(this.schema.model.entities).some(it => {
+			return Object.values(it.fields).some(field => {
+				return field.type === Model.ColumnType.Enum && field.columnType === this.data.enumName && field.list
+			})
+		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {

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

@@ -1,6 +1,6 @@
 import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { c, createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
@@ -35,3 +35,45 @@ describe('update enum', () => testMigrations({
 	sql: SQL`ALTER DOMAIN "postStatus" DROP CONSTRAINT poststatus_check;
 	ALTER DOMAIN "postStatus" ADD CONSTRAINT poststatus_check CHECK (VALUE IN('publish','draft'));`,
 }))
+
+
+namespace EnumModelOriginal {
+	export const FooStatus = c.createEnum('foo', 'bar')
+	export class Foo {
+
+		status = c.enumColumn(FooStatus).notNull()
+		statusList = c.enumColumn(FooStatus).notNull().list()
+	}
+}
+
+namespace EnumModelUpdated {
+	export const FooStatus = c.createEnum('foo', 'bar', 'baz')
+
+	export class Foo {
+
+		status = c.enumColumn(FooStatus).notNull()
+		statusList = c.enumColumn(FooStatus).notNull().list()
+	}
+}
+
+
+describe('update enum if used in list', () => testMigrations({
+	original: {
+		model: createSchema(EnumModelOriginal).model,
+	},
+	updated: {
+		model: createSchema(EnumModelUpdated).model,
+	},
+	diff: [
+		{
+			modification: 'updateEnum',
+			enumName: 'FooStatus',
+			values: ['foo', 'bar', 'baz'],
+		},
+	],
+	sql: SQL`ALTER DOMAIN "FooStatus" RENAME TO "FooStatus__old"; 
+CREATE DOMAIN "FooStatus" AS text CONSTRAINT "foostatus_check" CHECK (VALUE IN('foo','bar','baz')); 
+ALTER TABLE "foo" ALTER "status" SET DATA TYPE "FooStatus"; 
+ALTER TABLE "foo" ALTER "status_list" SET DATA TYPE "FooStatus"[]; 
+DROP DOMAIN "FooStatus__old";`,
+}))