@contember/schema-migrations 2.1.0-alpha.3 → 2.1.0-alpha.30

package/package.json

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

package/src/SchemaDiffer.ts

@@ -109,7 +109,7 @@ export class SchemaDiffer {
 			new UpdateEntityOrderByDiffer(),
 			new UpdateTargetDiffer(),
 			new CreateTargetDiffer(),
-			new UpdateTriggerDiffer(),
+			new UpdateTriggerDiffer(this.options),
 			new CreateTriggerDiffer(),
 			new RemoveTriggerDiffer(),
 			new RemoveTargetDiffer(),

package/src/modifications/ModificationHandlerFactory.ts

@@ -30,7 +30,7 @@ import {
 import { patchValidationSchemaModification, updateValidationSchemaModification } from './validation'
 import { createIndexModification, removeIndexModification } from './indexes'
 import { updateSettingsModification } from './settings'
-import { createTriggerModification, removeTriggerModification, updateTriggerModification } from './actions'
+import { createTriggerModification, patchTriggerModification, removeTriggerModification, updateTriggerModification } from './actions'
 import { createTargetModification } from './actions/CreateTargetModification'
 import { removeTargetModification } from './actions/RemoveTargetModification'
 import { updateTargetModification } from './actions/UpdateTargetModification'
@@ -94,6 +94,7 @@ namespace ModificationHandlerFactory {
 		updateEntityOrderByModification,
 		createTriggerModification,
 		updateTriggerModification,
+		patchTriggerModification,
 		removeTriggerModification,
 		createTargetModification,
 		updateTargetModification,

package/src/modifications/acl/UpdateAclSchemaModification.ts

@@ -44,7 +44,7 @@ export class UpdateAclSchemaDiffer implements Differ {
 			return []
 		}
 		const patch = createPatch(originalSchema.acl, updatedSchema.acl)
-		if (patch.length <= (this.options?.maxPatchSize ?? 100)) {
+		if (patch.length <= (this.options?.maxPatchSize ?? 1000)) {
 			return [patchAclSchemaModification.createModification({ patch })]
 		}
 		return [updateAclSchemaModification.createModification({ schema: updatedSchema.acl })]

package/src/modifications/actions/PatchTriggerModification.ts

@@ -0,0 +1,51 @@
+import { Actions } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, ModificationHandler } from '../ModificationHandler'
+import { applyPatch, Operation } from 'rfc6902'
+import deepCopy from '../../utils/deepCopy'
+
+export class PatchTriggerModificationHandler implements ModificationHandler<PatchTriggerModificationData> {
+	constructor(private readonly data: PatchTriggerModificationData) {}
+
+	public createSql(): void {}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const trigger = deepCopy(schema.actions.triggers[this.data.triggerName])
+
+			if (!trigger) {
+				throw new Error(`Trigger ${this.data.triggerName} not found`)
+			}
+
+			const result = applyPatch(trigger, this.data.patch).filter(it => it !== null)
+			if (result.length > 0) {
+				throw result[0]
+			}
+
+			return {
+				...schema,
+				actions: {
+					...schema.actions,
+					triggers: {
+						...schema.actions.triggers,
+						[this.data.triggerName]: trigger,
+					},
+				},
+			}
+		}
+	}
+
+	describe() {
+		return { message: `Patch trigger ${this.data.triggerName}` }
+	}
+}
+
+export interface PatchTriggerModificationData {
+	triggerName: string
+	patch: Operation[]
+}
+
+export const patchTriggerModification = createModificationType({
+	id: 'patchTrigger',
+	handler: PatchTriggerModificationHandler,
+})

package/src/modifications/actions/UpdateTriggerModification.ts

@@ -2,6 +2,8 @@ import { Actions, Schema } from '@contember/schema'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
+import { createPatch } from 'rfc6902'
+import { patchTriggerModification } from './PatchTriggerModification'
 
 export class UpdateTriggerModificationHandler implements ModificationHandler<UpdateTriggerModificationData> {
 	constructor(private readonly data: UpdateTriggerModificationData) {
@@ -40,9 +42,28 @@ export const updateTriggerModification = createModificationType({
 })
 
 export class UpdateTriggerDiffer implements Differ {
+	constructor(
+		private readonly options?: {
+			maxPatchSize?: number
+		},
+	) {
+	}
+
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.entries(updatedSchema.actions.triggers)
 			.filter(([name, trigger]) => originalSchema.actions.triggers[name] && !deepEqual(trigger, originalSchema.actions.triggers[name]))
-			.map(([, trigger]) => updateTriggerModification.createModification({ trigger }))
+			.map(([name, trigger]) => {
+				const originalTrigger = originalSchema.actions.triggers[name]
+
+				const patch = createPatch(originalTrigger, trigger)
+				if (patch.length <= (this.options?.maxPatchSize ?? 1000)) {
+					return patchTriggerModification.createModification({
+						triggerName: name,
+						patch,
+					})
+				}
+
+				return updateTriggerModification.createModification({ trigger })
+			})
 	}
 }

package/src/modifications/actions/index.ts

@@ -1,3 +1,4 @@
 export * from './CreateTriggerModification'
 export * from './RemoveTriggerModification'
 export * from './UpdateTriggerModification'
+export * from './PatchTriggerModification'

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,8 +34,9 @@ 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'
-			builder.sql(`CREATE UNIQUE INDEX ON ${tableNameId} (${columnNameIds.join(', ')})${nulls}`)
+			const nulls = this.data.unique.nulls === 'not distinct' ? ' NULLS NOT DISTINCT' : ''
+			const methodClause = this.data.unique.method ? ` USING ${this.data.unique.method}` : ''
+			builder.sql(`CREATE UNIQUE INDEX ON ${tableNameId}${methodClause} (${columnNameIds.join(', ')})${nulls}`)
 		} else {
 			let checkModifier = ''
 			if (this.data.unique.timing === 'deferred') {

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/src/modifications/indexes/CreateIndexModification.ts

@@ -28,8 +28,9 @@ export class CreateIndexModificationHandler implements ModificationHandler<Creat
 
 		const tableNameId = wrapIdentifier(entity.tableName)
 		const columnNameIds = columns.map(wrapIdentifier)
+		const methodClause = this.data.index.method ? ` USING ${this.data.index.method}` : ''
 
-		builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameIds.join(', ')})`)
+		builder.sql(`CREATE INDEX ON ${tableNameId}${methodClause} (${columnNameIds.join(', ')})`)
 
 		invalidateDatabaseMetadata()
 	}
@@ -47,8 +48,9 @@ export class CreateIndexModificationHandler implements ModificationHandler<Creat
 	}
 
 	describe() {
+		const methodText = this.data.index.method ? ` using ${this.data.index.method}` : ''
 		return {
-			message: `Create index(${this.data.index.fields.join(', ')}) on entity ${this.data.entityName}`,
+			message: `Create index(${this.data.index.fields.join(', ')})${methodText} on entity ${this.data.entityName}`,
 		}
 	}
 }

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

@@ -17,6 +17,34 @@ namespace SchemaWithIndex {
 	}
 }
 
+namespace SchemaWithGinIndex {
+	@def.Index({ fields: ['title'], method: 'gin' })
+	export class Article {
+		title = def.stringColumn()
+	}
+}
+
+namespace SchemaWithGistIndex {
+	@def.Index({ fields: ['title'], method: 'gist' })
+	export class Article {
+		title = def.stringColumn()
+	}
+}
+
+namespace SchemaWithBtreeIndex {
+	@def.Index({ fields: ['title'], method: 'btree' })
+	export class Article {
+		title = def.stringColumn()
+	}
+}
+
+namespace SchemaWithHashIndex {
+	@def.Index({ fields: ['title'], method: 'hash' })
+	export class Article {
+		title = def.stringColumn()
+	}
+}
+
 
 describe('create index', () => testMigrations({
 	original: createSchema(SchemaWithoutIndex),
@@ -54,3 +82,75 @@ describe('drop index', () => testMigrations({
 		uniqueConstraints: [],
 	}),
 }))
+
+
+describe('create index with GIN method', () => testMigrations({
+	original: createSchema(SchemaWithoutIndex),
+	updated: createSchema(SchemaWithGinIndex),
+	diff: [
+		{
+			modification: 'createIndex',
+			entityName: 'Article',
+			index: { fields: ['title'], method: 'gin' },
+		},
+	],
+	sql: SQL`CREATE INDEX ON "article" USING gin ("title");`,
+}))
+
+describe('change index method from btree to gin', () => testMigrations({
+	original: createSchema(SchemaWithBtreeIndex),
+	updated: createSchema(SchemaWithGinIndex),
+	diff: [
+		{
+			modification: 'removeIndex',
+			entityName: 'Article',
+			fields: ['title'],
+		},
+		{
+			modification: 'createIndex',
+			entityName: 'Article',
+			index: { fields: ['title'], method: 'gin' },
+		},
+	],
+	sql: SQL`DROP INDEX "idx_article_title";
+CREATE INDEX ON "article" USING gin ("title");`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [{
+			tableName: 'article',
+			columnNames: ['title'],
+			indexName: 'idx_article_title',
+			unique: false,
+		}],
+		uniqueConstraints: [],
+	}),
+}))
+
+describe('change from regular index to method-specific index', () => testMigrations({
+	original: createSchema(SchemaWithIndex),
+	updated: createSchema(SchemaWithHashIndex),
+	diff: [
+		{
+			modification: 'removeIndex',
+			entityName: 'Article',
+			fields: ['title'],
+		},
+		{
+			modification: 'createIndex',
+			entityName: 'Article',
+			index: { fields: ['title'], method: 'hash' },
+		},
+	],
+	sql: SQL`DROP INDEX "idx_article_title";
+CREATE INDEX ON "article" USING hash ("title");`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [{
+			tableName: 'article',
+			columnNames: ['title'],
+			indexName: 'idx_article_title',
+			unique: false,
+		}],
+		uniqueConstraints: [],
+	}),
+}))

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

@@ -104,7 +104,7 @@ describe('change unique timing', () => testMigrations({
 			},
 		}),
 	],
-	sql: SQL`ALTER TABLE "author" DROP CONSTRAINT "uniq_author_email"; 
+	sql: SQL`ALTER TABLE "author" DROP CONSTRAINT "uniq_author_email";
 ALTER TABLE "author" ADD UNIQUE ("email") DEFERRABLE;`,
 	databaseMetadata: createDatabaseMetadata({
 		foreignKeys: [],
@@ -233,5 +233,157 @@ describe('create unique index', () => testMigrations({
 			},
 		}),
 	],
-	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email") NULLS DISTINCT;`,
+	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email");`,
+}))
+
+namespace AuthorWithUniqueGinIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'gin' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+namespace AuthorWithUniqueGistIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'gist' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+namespace AuthorWithUniqueBtreeIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'btree', nulls: 'not distinct' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+describe('create unique index with GIN method', () => testMigrations({
+	original: createSchema({
+		Author: class Author {
+			email = c.stringColumn()
+		},
+	}),
+	updated: createSchema(AuthorWithUniqueGinIndex),
+	diff: [
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'gin',
+			},
+		}),
+	],
+	sql: SQL`CREATE UNIQUE INDEX ON "author" USING gin ("email");`,
+}))
+
+describe('create unique index with GiST method', () => testMigrations({
+	original: createSchema({
+		Author: class Author {
+			email = c.stringColumn()
+		},
+	}),
+	updated: createSchema(AuthorWithUniqueGistIndex),
+	diff: [
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'gist',
+			},
+		}),
+	],
+	sql: SQL`CREATE UNIQUE INDEX ON "author" USING gist ("email");`,
+}))
+
+describe('create unique index with btree method and nulls not distinct', () => testMigrations({
+	original: createSchema({
+		Author: class Author {
+			email = c.stringColumn()
+		},
+	}),
+	updated: createSchema(AuthorWithUniqueBtreeIndex),
+	diff: [
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'btree',
+				nulls: 'not distinct',
+			},
+		}),
+	],
+	sql: SQL`CREATE UNIQUE INDEX ON "author" USING btree ("email") NULLS NOT DISTINCT;`,
+}))
+
+describe('change unique index method from gin to gist', () => testMigrations({
+	original: createSchema(AuthorWithUniqueGinIndex),
+	updated: createSchema(AuthorWithUniqueGistIndex),
+	diff: [
+		removeUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'gin',
+			},
+		}),
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'gist',
+			},
+		}),
+	],
+	sql: SQL`DROP INDEX "uniq_author_email";
+CREATE UNIQUE INDEX ON "author" USING gist ("email");`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [{
+			tableName: 'author',
+			columnNames: ['email'],
+			indexName: 'uniq_author_email',
+			unique: true,
+		}],
+		uniqueConstraints: [],
+	}),
+}))
+
+describe('change from regular unique index to method-specific unique index', () => testMigrations({
+	original: createSchema(AuthorWithUniqueIndex),
+	updated: createSchema(AuthorWithUniqueGinIndex),
+	diff: [
+		removeUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				nulls: 'not distinct',
+			},
+		}),
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				index: true,
+				method: 'gin',
+			},
+		}),
+	],
+	sql: SQL`DROP INDEX "uniq_author_email";
+CREATE UNIQUE INDEX ON "author" USING gin ("email");`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [{
+			tableName: 'author',
+			columnNames: ['email'],
+			indexName: 'uniq_author_email',
+			unique: true,
+		}],
+		uniqueConstraints: [],
+	}),
 }))