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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.1.0-alpha.2",
+  "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.2",
-    "@contember/database-migrations": "2.1.0-alpha.2",
-    "@contember/engine-common": "2.1.0-alpha.2",
-    "@contember/schema": "2.1.0-alpha.2",
-    "@contember/schema-utils": "2.1.0-alpha.2",
+    "@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.2"
+    "@contember/schema-definition": "2.1.0-alpha.21"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -28,7 +28,9 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 
 		const columnNameWrapped = wrapIdentifier(oldColumn.columnName)
 		const isChangedToArray = !oldColumn.list && newColumn.list
-		const usingCast = (isChangedToArray ? `ARRAY[${columnNameWrapped}]` : columnNameWrapped) + `::${columnType}`
+		const usingCast = isChangedToArray
+			? `CASE WHEN ${columnNameWrapped} IS NULL THEN ${newColumn.nullable ? 'NULL' : `ARRAY[]::${columnType}`} ELSE ARRAY[${columnNameWrapped}]::${columnType} END`
+			: `${columnNameWrapped}::${columnType}`
 
 		const seedExpression = formatSeedExpression({
 			model: this.schema.model,

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -34,7 +34,7 @@ export class CreateUniqueConstraintModificationHandler implements ModificationHa
 		const columnNameIds = columns.map(wrapIdentifier)
 
 		if ('index' in this.data.unique && this.data.unique.index) {
-			const nulls = this.data.unique.nulls === 'not distinct' ? ' NULLS NOT DISTINCT' : ' NULLS DISTINCT'
+			const nulls = this.data.unique.nulls === 'not distinct' ? ' NULLS NOT DISTINCT' : ''
 			builder.sql(`CREATE UNIQUE INDEX ON ${tableNameId} (${columnNameIds.join(', ')})${nulls}`)
 		} else {
 			let checkModifier = ''

package/src/modifications/entities/RemoveEntityModification.ts

@@ -31,7 +31,11 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
-			builder.dropView(entity.tableName)
+			if (entity.view.materialized) {
+				builder.dropMaterializedView(entity.tableName)
+			} else {
+				builder.dropView(entity.tableName)
+			}
 			return
 		}
 		if (this.options.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {

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/createUnique.test.ts

@@ -233,5 +233,5 @@ describe('create unique index', () => testMigrations({
 			},
 		}),
 	],
-	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email") NULLS DISTINCT;`,
+	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email");`,
 }))

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

@@ -251,5 +251,32 @@ describe('change string to array string', () => testMigrations({
 			},
 		}),
 	],
-	sql: SQL`ALTER TABLE "author" ALTER "email" SET DATA TYPE text[] USING ARRAY["email"]::text[];`,
+	sql: SQL`ALTER TABLE "author" ALTER "email" SET DATA TYPE text[] USING CASE WHEN "email" IS NULL THEN NULL ELSE ARRAY["email"]::text[] END;`,
+}))
+
+describe('change string to array string not null', () => testMigrations({
+	original: createSchema({
+		Author: class Author {
+			email = def.stringColumn().notNull()
+		},
+	}),
+	updated: createSchema({
+		Author: class Author {
+			email = def.stringColumn().list().notNull()
+		},
+	}),
+	diff: [
+		updateColumnDefinitionModification.createModification({
+			entityName: 'Author',
+			fieldName: 'email',
+			definition: {
+				type: Model.ColumnType.String,
+				columnType: 'text',
+				nullable: false,
+				list: true,
+			},
+		}),
+	],
+	sql: SQL`ALTER TABLE "author"
+        ALTER "email" SET DATA TYPE text[] USING CASE WHEN "email" IS NULL THEN ARRAY[]::text[] ELSE ARRAY["email"]::text[] END;`,
 }))

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";`,
+}))