@contember/schema-migrations 1.2.0-alpha.15 → 1.2.0-alpha.16

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

@@ -0,0 +1,314 @@
+import { test } from 'vitest'
+import { testGenerateSql } from '../../src/tests'
+import {
+	createEntityModification,
+	createRelationModification,
+	removeFieldModification,
+	updateEntityNameModification,
+} from '../../../src'
+import { emptyModelSchema } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { SQL } from '../../src/tags'
+
+test('taken fk index name', () => {
+	testGenerateSql(emptyModelSchema, [
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Author',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'author',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'author',
+				type: Model.RelationType.ManyHasOne,
+				target: 'Author',
+				joiningColumn: {
+					columnName: 'author_id',
+					onDelete: Model.OnDelete.cascade,
+				},
+				nullable: true,
+			},
+
+		}),
+		updateEntityNameModification.createModification({
+			entityName: 'Post',
+			newEntityName: 'Article',
+			tableName: 'article',
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'author',
+				type: Model.RelationType.ManyHasOne,
+				target: 'Author',
+				joiningColumn: {
+					columnName: 'author_id',
+					onDelete: Model.OnDelete.cascade,
+				},
+				nullable: true,
+			},
+
+		}),
+	], SQL`CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "author" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+ALTER TABLE "post"
+  ADD "author_id" uuid;
+ALTER TABLE "post"
+  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
+CREATE INDEX "post_author_id_index" ON "post" ("author_id");
+ALTER TABLE "post" RENAME TO "article";
+CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+ALTER TABLE "post"
+  ADD "author_id" uuid;
+ALTER TABLE "post"
+  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
+CREATE INDEX "post_author_id_index1" ON "post" ("author_id");`)
+})
+
+
+test('taken junction table index name', () => {
+	testGenerateSql(emptyModelSchema, [
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Author',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'author',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'authors',
+				type: Model.RelationType.ManyHasMany,
+				target: 'Author',
+				joiningTable: {
+					tableName: 'post_authors',
+					joiningColumn: {
+						columnName: 'post_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					inverseJoiningColumn: {
+						columnName: 'author_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					eventLog: {
+						enabled: true,
+					},
+				},
+			},
+		}),
+		removeFieldModification.createModification({
+			entityName: 'Post',
+			fieldName: 'authors',
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'authors',
+				type: Model.RelationType.ManyHasMany,
+				target: 'Author',
+				joiningTable: {
+					tableName: 'post_authors',
+					joiningColumn: {
+						columnName: 'post_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					inverseJoiningColumn: {
+						columnName: 'author_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					eventLog: {
+						enabled: true,
+					},
+				},
+			},
+		}),
+	], SQL`CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "author" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "post_authors" (
+  "post_id" uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
+  "author_id" uuid NOT NULL REFERENCES "author"("id") ON DELETE CASCADE
+);
+ALTER TABLE "post_authors"
+  ADD CONSTRAINT "post_authors_pkey" PRIMARY KEY ("post_id", "author_id");
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$post_id$pga$, $pga$author_id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+DROP TABLE "post_authors";
+CREATE TABLE "post_authors" (
+  "post_id" uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
+  "author_id" uuid NOT NULL REFERENCES "author"("id") ON DELETE CASCADE
+);
+ALTER TABLE "post_authors"
+  ADD CONSTRAINT "post_authors_pkey1" PRIMARY KEY ("post_id", "author_id");
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$post_id$pga$, $pga$author_id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+`)
+})

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

@@ -1,7 +1,8 @@
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { SchemaBuilder, SchemaDefinition as def, createSchema } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { updateColumnDefinitionModification } from '../../../src'
 
 testMigrations('update column definition', {
 	originalSchema: new SchemaBuilder()
@@ -31,3 +32,139 @@ testMigrations('update column definition', {
 	sql: SQL`ALTER TABLE "author"
 		ALTER "registered_at" SET DATA TYPE timestamptz USING "registered_at"::timestamptz;`,
 })
+
+namespace SeqOrig {
+	export class Author {
+		idSeq = def.intColumn()
+	}
+}
+namespace SeqUpdated {
+	export class Author {
+		idSeq = def.intColumn().notNull().sequence({ start: 10 })
+	}
+}
+testMigrations('add sequence to existing column', {
+	originalSchema: createSchema(SeqOrig).model,
+	updatedSchema: createSchema(SeqUpdated).model,
+	diff: [
+		updateColumnDefinitionModification.createModification({
+			entityName: 'Author',
+			fieldName: 'idSeq',
+			definition: {
+				type: Model.ColumnType.Int,
+				columnType: 'integer',
+				nullable: false,
+				sequence: {
+					precedence: 'BY DEFAULT',
+					start: 10,
+				},
+			},
+		}),
+	],
+	sql: SQL`
+ALTER TABLE "author"
+		ALTER "id_seq" SET DATA TYPE integer USING COALESCE("id_seq"::integer, nextval(PG_GET_SERIAL_SEQUENCE($pga$author$pga$, $pga$id_seq$pga$))),
+		ALTER "id_seq" SET NOT NULL,
+		ALTER "id_seq" ADD GENERATED BY DEFAULT AS IDENTITY (START WITH 10);`,
+})
+
+
+namespace ViewColDepOrig {
+	export class Author {
+		val = def.intColumn()
+	}
+
+	@def.View('SELECT * FROM author', {
+		dependencies: [Author],
+	})
+	export class AuthorMetaX {
+
+	}
+
+	@def.View('SELECT * FROM author_meta_x', {
+		dependencies: [AuthorMetaX],
+	})
+	export class AuthorMetaY {
+	}
+}
+
+namespace ViewColDepUpdated {
+	export class Author {
+		val = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author', {
+		dependencies: [Author],
+	})
+	export class AuthorMetaX {
+
+	}
+
+	@def.View('SELECT * FROM author_meta_x', {
+		dependencies: [AuthorMetaX],
+	})
+	export class AuthorMetaY {
+	}
+}
+
+testMigrations('recreate view dependent on entity after changing column type', {
+	originalSchema: createSchema(ViewColDepOrig).model,
+	updatedSchema: createSchema(ViewColDepUpdated).model,
+	diff: [{ modification: 'removeEntity', entityName: 'AuthorMetaY' }, {
+		modification: 'removeEntity',
+		entityName: 'AuthorMetaX',
+	}, {
+		modification: 'updateColumnDefinition',
+		entityName: 'Author',
+		fieldName: 'val',
+		definition: { nullable: true, type: 'String', columnType: 'text' },
+	}, {
+		modification: 'createView',
+		entity: {
+			name: 'AuthorMetaX',
+			primary: 'id',
+			primaryColumn: 'id',
+			unique: {},
+			indexes: {},
+			fields: {
+				id: {
+					name: 'id',
+					columnName: 'id',
+					nullable: false,
+					type: 'Uuid',
+					columnType: 'uuid',
+				},
+			},
+			tableName: 'author_meta_x',
+			eventLog: { enabled: true },
+			view: { sql: 'SELECT * FROM author', dependencies: ['Author'] },
+		},
+	}, {
+		modification: 'createView',
+		entity: {
+			name: 'AuthorMetaY',
+			primary: 'id',
+			primaryColumn: 'id',
+			unique: {},
+			indexes: {},
+			fields: {
+				id: {
+					name: 'id',
+					columnName: 'id',
+					nullable: false,
+					type: 'Uuid',
+					columnType: 'uuid',
+				},
+			},
+			tableName: 'author_meta_y',
+			eventLog: { enabled: true },
+			view: { sql: 'SELECT * FROM author_meta_x', dependencies: ['AuthorMetaX'] },
+		},
+	}],
+	sql: SQL`DROP VIEW "author_meta_y";
+DROP VIEW "author_meta_x";
+ALTER TABLE "author"
+  ALTER "val" SET DATA TYPE text USING "val"::text;
+CREATE VIEW "author_meta_x" AS SELECT * FROM author;
+CREATE VIEW "author_meta_y" AS SELECT * FROM author_meta_x;`,
+})

package/tests/src/tests.ts

@@ -2,6 +2,7 @@ import { Migration, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VE
 import { Acl, Model } from '@contember/schema'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { assert, describe, it } from 'vitest'
+import { SchemaWithMeta } from '../../src/modifications/utils/schemaMeta'
 
 const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
 const schemaMigrator = new SchemaMigrator(modificationFactory)
@@ -32,11 +33,11 @@ export function testDiffSchemas(
 		false,
 	)
 	assert.deepStrictEqual(actualDiff, expectedDiff)
-	const schema = schemaMigrator.applyModifications(
+	const { meta, ...schema } = schemaMigrator.applyModifications(
 		{ model: originalModel, acl: originalAcl, validation: {} },
 		actualDiff,
 		VERSION_LATEST,
-	)
+	) as SchemaWithMeta
 	assert.deepStrictEqual(schema, {
 		model: updatedModel,
 		acl: updatedAcl,
@@ -51,11 +52,11 @@ export function testApplyDiff(
 	originalAcl: Acl.Schema = emptyAcl,
 	expectedAcl: Acl.Schema = emptyAcl,
 ) {
-	const actualSchema = schemaMigrator.applyModifications(
+	const { meta, ...actualSchema } = schemaMigrator.applyModifications(
 		{ model: originalModel, acl: originalAcl, validation: {} },
 		diff,
 		VERSION_LATEST,
-	)
+	) as SchemaWithMeta
 
 	assert.deepStrictEqual(actualSchema, {
 		model: expectedModel,