@contember/schema-migrations 1.0.0-rc.9 → 1.0.0

package/src/modifications/relations/CreateRelationModification.ts

@@ -9,14 +9,11 @@ import {
 import { MigrationBuilder } from '@contember/database-migrations'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
 import { isIt } from '../../utils/isIt'
 import { createFields } from '../utils/diffUtils'
+import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
+import { createJunctionTableSql } from '../utils/createJunctionTable'
 
-const getPrimaryType = (entity: Model.Entity): string => {
-	const column = entity.fields[entity.primary] as Model.AnyColumn
-	return column.columnType
-}
 
 export const CreateRelationModification: ModificationHandlerStatic<CreateRelationModificationData> = class {
 	static id = 'createRelation'
@@ -32,7 +29,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 		const createOwningSide = (relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation) => {
 			builder.addColumn(entity.tableName, {
 				[relation.joiningColumn.columnName]: {
-					type: getPrimaryType(targetEntity),
+					type: getPrimaryColumnType(targetEntity),
 					notNull: !relation.nullable,
 				},
 			})
@@ -65,34 +62,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({}, relation, {}, _) => {
-				const primaryColumns = [
-					relation.joiningTable.joiningColumn.columnName,
-					relation.joiningTable.inverseJoiningColumn.columnName,
-				]
-				builder.createTable(
-					relation.joiningTable.tableName,
-					{
-						[relation.joiningTable.joiningColumn.columnName]: {
-							type: getPrimaryType(entity),
-							notNull: true,
-							references: `"${entity.tableName}"("${entity.primaryColumn}")`,
-							onDelete: 'CASCADE',
-						},
-						[relation.joiningTable.inverseJoiningColumn.columnName]: {
-							type: getPrimaryType(targetEntity),
-							notNull: true,
-							references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
-							onDelete: 'CASCADE',
-						},
-					},
-					{
-						constraints: {
-							primaryKey: primaryColumns,
-						},
-					},
-				)
-				createEventTrigger(builder, relation.joiningTable.tableName, primaryColumns)
-				createEventTrxTrigger(builder, relation.joiningTable.tableName)
+				createJunctionTableSql(builder, entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})

package/src/modifications/relations/index.ts

@@ -1,3 +1,4 @@
+export * from './ConvertOneHasManyToManyHasManyRelationModification'
 export * from './ConvertOneToManyRelationModification'
 export * from './CreateRelationInverseSideModification'
 export * from './CreateRelationModification'

package/src/modifications/utils/createJunctionTable.ts

@@ -0,0 +1,40 @@
+import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model } from '@contember/schema'
+import { getPrimaryColumnType } from './getPrimaryColumnType'
+
+export const createJunctionTableSql = (
+	builder: MigrationBuilder,
+	entity: Model.Entity,
+	targetEntity: Model.Entity,
+	relation: Model.ManyHasManyOwningRelation,
+) => {
+	const primaryColumns = [
+		relation.joiningTable.joiningColumn.columnName,
+		relation.joiningTable.inverseJoiningColumn.columnName,
+	]
+	builder.createTable(
+		relation.joiningTable.tableName,
+		{
+			[relation.joiningTable.joiningColumn.columnName]: {
+				type: getPrimaryColumnType(entity),
+				notNull: true,
+				references: `"${entity.tableName}"("${entity.primaryColumn}")`,
+				onDelete: 'CASCADE',
+			},
+			[relation.joiningTable.inverseJoiningColumn.columnName]: {
+				type: getPrimaryColumnType(targetEntity),
+				notNull: true,
+				references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
+				onDelete: 'CASCADE',
+			},
+		},
+		{
+			constraints: {
+				primaryKey: primaryColumns,
+			},
+		},
+	)
+	createEventTrigger(builder, relation.joiningTable.tableName, primaryColumns)
+	createEventTrxTrigger(builder, relation.joiningTable.tableName)
+}

package/src/modifications/utils/getPrimaryColumnType.ts

@@ -0,0 +1,6 @@
+import { Model } from '@contember/schema'
+
+export const getPrimaryColumnType = (entity: Model.Entity): string => {
+	const column = entity.fields[entity.primary] as Model.AnyColumn
+	return column.columnType
+}

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

@@ -0,0 +1,81 @@
+import { testMigrations } from '../../src/tests'
+import { SQL } from '../../src/tags'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
+namespace ConvertOHMToMHMSchemaOrig {
+	export class Article {
+		title = def.stringColumn()
+		category = def.manyHasOne(Category, 'articles')
+	}
+
+	export class Category {
+		articles = def.oneHasMany(Article, 'category')
+	}
+}
+
+namespace ConvertOHMToMHMSchemaOrigUpdated {
+	export class Article {
+		title = def.stringColumn()
+		categories = def.manyHasMany(Category, 'articles')
+	}
+
+	export class Category {
+		articles = def.manyHasManyInverse(Article, 'categories')
+	}
+}
+
+
+testMigrations('convert one has many to many has many', {
+	originalSchema: def.createModel(ConvertOHMToMHMSchemaOrig),
+	updatedSchema: def.createModel(ConvertOHMToMHMSchemaOrigUpdated),
+	diff: [
+		{
+			modification: 'convertOneHasManyToManyHasManyRelation',
+			entityName: 'Article',
+			fieldName: 'category',
+			owningSide: {
+				type: 'ManyHasMany',
+				name: 'categories',
+				inversedBy: 'articles',
+				target: 'Category',
+				joiningTable: {
+					tableName: 'article_categories',
+					joiningColumn: {
+						columnName: 'article_id',
+						onDelete: 'cascade',
+					},
+					inverseJoiningColumn: {
+						columnName: 'category_id',
+						onDelete: 'cascade',
+					},
+				},
+			},
+			inverseSide: {
+				name: 'articles',
+				ownedBy: 'categories',
+				target: 'Article',
+				type: 'ManyHasMany',
+			},
+		},
+	],
+	sql: SQL`
+	CREATE TABLE "article_categories" (
+		"article_id" uuid NOT NULL REFERENCES "article"("id") ON DELETE CASCADE,
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE, CONSTRAINT
+		"article_categories_pkey" PRIMARY KEY ("article_id", "category_id")
+	);
+
+	CREATE TRIGGER "log_event" AFTER INSERT OR UPDATE OR DELETE
+	    ON "article_categories" FOR EACH ROW
+	    EXECUTE PROCEDURE "system"."trigger_event"($pga$article_id$pga$, $pga$category_id$pga$);
+
+	CREATE CONSTRAINT TRIGGER "log_event_trx" AFTER INSERT OR UPDATE OR DELETE
+	    ON "article_categories" DEFERRABLE INITIALLY DEFERRED FOR EACH ROW
+	    EXECUTE PROCEDURE "system"."trigger_event_commit"();
+
+	INSERT INTO "article_categories" ( "article_id", "category_id" )
+	SELECT "id", "category_id" FROM "article" WHERE "category_id" IS NOT NULL;
+
+	ALTER TABLE "article" DROP "category_id";
+	`,
+})

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

@@ -29,5 +29,5 @@ testMigrations('update column definition', {
 		},
 	],
 	sql: SQL`ALTER TABLE "author"
-		ALTER "registered_at" SET DATA TYPE timestamptz;`,
+		ALTER "registered_at" SET DATA TYPE timestamptz USING "registered_at"::timestamptz;`,
 })