@contember/schema-migrations 1.4.0-rc.2 → 1.4.0-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "1.4.0-rc.2",
+  "version": "1.4.0-rc.4",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -12,16 +12,16 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/database": "1.4.0-rc.2",
-    "@contember/database-migrations": "1.4.0-rc.2",
-    "@contember/engine-common": "1.4.0-rc.2",
-    "@contember/schema": "1.4.0-rc.2",
-    "@contember/schema-utils": "1.4.0-rc.2",
+    "@contember/database": "1.4.0-rc.4",
+    "@contember/database-migrations": "1.4.0-rc.4",
+    "@contember/engine-common": "1.4.0-rc.4",
+    "@contember/schema": "1.4.0-rc.4",
+    "@contember/schema-utils": "1.4.0-rc.4",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.0.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "1.4.0-rc.2"
+    "@contember/schema-definition": "1.4.0-rc.4"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/modifications/columns/CreateColumnModification.ts

@@ -5,7 +5,7 @@ import { createModificationType, Differ, ModificationHandler } from '../Modifica
 import { isColumn } from '@contember/schema-utils'
 import { createFields } from '../utils/diffUtils'
 import { getColumnSqlType } from '../utils/columnUtils'
-import { fillSeed } from './columnUtils'
+import { fillSeed, formatSeedExpression } from './columnUtils'
 
 export class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
 	constructor(private readonly data: CreateColumnModificationData, private readonly schema: Schema) {}
@@ -16,28 +16,43 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 			return
 		}
 		const column = this.data.field
-		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
+
 		const columnType = getColumnSqlType(column)
+
+		const seedExpression = formatSeedExpression({
+			model: this.schema.model,
+			entity,
+			columnType,
+			fillValue: this.data.fillValue,
+			copyValue: this.data.copyValue,
+		})
+
+
 		builder.addColumn(entity.tableName, {
 			[column.columnName]: {
 				type: columnType,
-				notNull: !column.nullable && !hasSeed,
+				notNull: !column.nullable && seedExpression === null,
 				sequenceGenerated: column.sequence,
 			},
 		})
 
-		if (hasSeed) {
-			fillSeed({
-				builder,
-				type: 'creating',
-				model: this.schema.model,
-				entity,
-				columnName: column.columnName,
-				nullable: column.nullable,
-				columnType,
-				copyValue: this.data.copyValue,
-				fillValue: this.data.fillValue,
-			})
+		if (seedExpression !== null) {
+			if (this.data.valueMigrationStrategy === 'using') {
+				builder.alterColumn(entity.tableName, column.columnName, {
+					notNull: !column.nullable ? true : undefined,
+					type: columnType,
+					using: seedExpression,
+				})
+			} else {
+				fillSeed({
+					builder,
+					type: 'creating',
+					entity,
+					columnName: column.columnName,
+					nullable: column.nullable,
+					seedExpression,
+				})
+			}
 		}
 	}
 
@@ -61,6 +76,7 @@ export interface CreateColumnModificationData {
 	field: Model.AnyColumn
 	fillValue?: JSONValue
 	copyValue?: string
+	valueMigrationStrategy?: 'using' | 'update'
 }
 
 
@@ -78,7 +94,7 @@ export class CreateColumnDiffer implements Differ {
 			return createColumnModification.createModification({
 				entityName: updatedEntity.name,
 				field: newField,
-				...(newField.default !== undefined ? { fillValue: newField.default } : {}),
+				...(newField.default !== undefined ? { fillValue: newField.default, valueMigrationStrategy: 'using' } : {}),
 			})
 		})
 	}

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -6,7 +6,7 @@ import deepEqual from 'fast-deep-equal'
 import { updateColumns } from '../utils/diffUtils'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 import { getColumnSqlType } from '../utils/columnUtils'
-import { fillSeed } from './columnUtils'
+import { fillSeed, formatSeedExpression } from './columnUtils'
 
 export class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData>  {
 	constructor(private readonly data: UpdateColumnDefinitionModificationData, private readonly schema: Schema) {}
@@ -22,33 +22,48 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 		const hasNewSequence = !oldColumn.sequence && newColumn.sequence
 		const hasNewType = newColumn.columnType !== oldColumn.columnType
 		const columnType = getColumnSqlType(newColumn)
+		const hasNullableChanged = oldColumn.nullable !== newColumn.nullable
 
 		const usingCast = `${wrapIdentifier(oldColumn.columnName)}::${columnType}`
 
-		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
+		const seedExpression = formatSeedExpression({
+			model: this.schema.model,
+			entity,
+			columnType,
+			fillValue: this.data.fillValue,
+			copyValue: this.data.copyValue,
+		})
+		const hasSeed = seedExpression !== null
+		const migrateWithUsing = hasSeed && this.data.valueMigrationStrategy === 'using'
+		const migrateWithUpdate = hasSeed && this.data.valueMigrationStrategy !== 'using'
 
 		builder.alterColumn(entity.tableName, oldColumn.columnName, {
-			type: hasNewSequence || hasNewType ? columnType : undefined,
-			notNull: oldColumn.nullable !== newColumn.nullable && (!hasSeed || newColumn.nullable) ? !newColumn.nullable : undefined,
-			using: hasNewSequence
-				? `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
-				: hasNewType
-					? usingCast
-					: undefined,
+			type: hasNewSequence || hasNewType || migrateWithUsing ? columnType : undefined,
+			notNull: hasNullableChanged && (!migrateWithUpdate || newColumn.nullable) ? !newColumn.nullable : undefined,
+			using: (() => {
+				if (hasNewSequence) {
+					return `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
+				}
+				if (migrateWithUsing) {
+					return `COALESCE(${usingCast}, ${seedExpression})`
+				}
+
+				if (hasNewType) {
+					return usingCast
+				}
+				return undefined
+			})(),
 			sequenceGenerated: oldColumn.sequence && !newColumn.sequence ? false : (!oldColumn.sequence ? newColumn.sequence : undefined),
 		})
 
-		if (hasSeed) {
+		if (migrateWithUpdate) {
 			fillSeed({
 				builder,
 				type: 'updating',
-				model: this.schema.model,
 				entity,
 				columnName: oldColumn.columnName,
 				nullable: newColumn.nullable,
-				columnType,
-				copyValue: this.data.copyValue,
-				fillValue: this.data.fillValue,
+				seedExpression,
 			})
 		}
 
@@ -114,6 +129,7 @@ export interface UpdateColumnDefinitionModificationData {
 	definition: ColumnDefinitionAlter
 	fillValue?: JSONValue
 	copyValue?: string
+	valueMigrationStrategy?: 'using' | 'update'
 }
 
 export const updateColumnDefinitionModification = createModificationType({

package/src/modifications/columns/columnUtils.ts

@@ -1,31 +1,20 @@
 import { wrapIdentifier } from '../../utils/dbHelpers'
-import { ImplementationException } from '../../exceptions'
 import { JSONValue, Model } from '@contember/schema'
 import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { getColumnName } from '@contember/schema-utils'
 
-export const fillSeed = ({ builder, fillValue, copyValue, entity, columnName, nullable, model, columnType, type }: {
-	model: Model.Schema
+export const fillSeed = ({ builder, entity, columnName, nullable, type, seedExpression }: {
 	entity: Model.Entity
 	columnName: string
-	columnType: string
 	nullable: boolean
 	builder: MigrationBuilder
-	fillValue?: JSONValue
-	copyValue?: string
 	type: 'creating' | 'updating'
+	seedExpression: string
 }) => {
+
 	const where = type === 'updating' ? ` WHERE ${wrapIdentifier(columnName)} IS NULL` : ''
-	if (fillValue !== undefined) {
-		builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
-                     SET ${wrapIdentifier(columnName)} = ${escapeValue(fillValue)}${where}`)
-	} else if (copyValue !== undefined) {
-		const copyFrom = getColumnName(model, entity, copyValue)
-		builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
-                     SET ${wrapIdentifier(columnName)} = ${wrapIdentifier(copyFrom)}::${columnType}${where}`)
-	} else {
-		throw new ImplementationException()
-	}
+	builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
+				 SET ${wrapIdentifier(columnName)} = ${seedExpression}${where}`)
 
 	// event log uses deferred constraint triggers, we need to fire them before ALTER
 	builder.sql(`SET CONSTRAINTS ALL IMMEDIATE`)
@@ -37,3 +26,20 @@ export const fillSeed = ({ builder, fillValue, copyValue, entity, columnName, nu
 		})
 	}
 }
+
+
+export const formatSeedExpression = ({ model, entity, columnType, fillValue, copyValue }: {
+	model: Model.Schema
+	entity: Model.Entity
+	columnType: string
+	fillValue?: JSONValue
+	copyValue?: string
+}): string | null => {
+	if (fillValue !== undefined) {
+		return escapeValue(fillValue)
+	} else if (copyValue !== undefined) {
+		const copyFrom = getColumnName(model, entity, copyValue)
+		return `${wrapIdentifier(copyFrom)}::${columnType}`
+	}
+	return null
+}

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

@@ -11,10 +11,11 @@ testMigrations('create a column with default value', {
 	}),
 	updated: createSchema({
 		Author: class Author {
-			name = def.stringColumn().default('unnamed author').notNull()
+			name = def.stringColumn().notNull()
 			email = def.stringColumn().unique()
 		},
 	}),
+	noDiff: true,
 	diff: [
 		{
 			modification: 'createColumn',
@@ -23,7 +24,6 @@ testMigrations('create a column with default value', {
 				columnName: 'name',
 				name: 'name',
 				nullable: false,
-				default: 'unnamed author',
 				type: Model.ColumnType.String,
 				columnType: 'text',
 			},
@@ -68,3 +68,36 @@ UPDATE "author" SET "name" = "email"::text;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
 })
+
+
+testMigrations('create a column with default value with "using"', {
+	original: createSchema({
+		Author: class Author {
+			email = def.stringColumn().unique()
+		},
+	}),
+	updated: createSchema({
+		Author: class Author {
+			name = def.stringColumn().default('unnamed author').notNull()
+			email = def.stringColumn().unique()
+		},
+	}),
+	diff: [
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'name',
+				name: 'name',
+				nullable: false,
+				default: 'unnamed author',
+				type: Model.ColumnType.String,
+				columnType: 'text',
+			},
+			fillValue: 'unnamed author',
+			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;`,
+})

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

@@ -205,3 +205,23 @@ UPDATE "author" SET "name" = $pga$unnamed$pga$ WHERE "name" IS NULL;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
 })
+
+testMigrations('set not null and fill with "using"', {
+	original: createSchema(NotNullOrig),
+	updated: createSchema(NotNullUpdated),
+	noDiff: true,
+	diff: [
+		updateColumnDefinitionModification.createModification({
+			entityName: 'Author',
+			fieldName: 'name',
+			definition: {
+				type: Model.ColumnType.String,
+				columnType: 'text',
+				nullable: false,
+			},
+			fillValue: 'unnamed',
+			valueMigrationStrategy: 'using',
+		}),
+	],
+	sql: SQL` ALTER TABLE "author" ALTER "name" SET DATA TYPE text USING COALESCE("name"::text, $pga$unnamed$pga$), ALTER "name" SET NOT NULL;`,
+})