@contember/schema-migrations 1.2.0-alpha.8 → 1.2.0-beta.1

package/src/modifications/utils/viewDependencies.ts

@@ -1,8 +1,10 @@
 import { Model } from '@contember/schema'
+import { Migration } from '../../Migration'
+import { removeEntityModification } from '../entities'
 
-type ViewDependants = Map<string, Set<Model.Entity>>
-export const getViewDirectDependants = (model: Model.Schema): ViewDependants => {
-	const dependants: ViewDependants = new Map(Object.values(model.entities).filter(it => it.view).map(it => [it.name, new Set()]))
+type EntityDependantViews = Map<string, Set<Model.Entity>>
+export const getEntityDependantViews = (model: Model.Schema): EntityDependantViews => {
+	const dependants: EntityDependantViews = new Map(Object.values(model.entities).map(it => [it.name, new Set()]))
 	for (const entity of Object.values(model.entities)) {
 		if (!entity.view?.dependencies?.length) {
 			continue
@@ -10,11 +12,32 @@ export const getViewDirectDependants = (model: Model.Schema): ViewDependants =>
 		for (const dependency of entity.view.dependencies) {
 			const entityDependants = dependants.get(dependency)
 			if (!entityDependants) {
-				// not a view
-				continue
+				throw new Error()
 			}
 			entityDependants.add(entity)
 		}
 	}
 	return dependants
 }
+
+export const cascadeRemoveDependantViews = (model: Model.Schema, entities: Model.Entity[]): Migration.Modification[] => {
+	const removed = new Set<string>()
+	const dependants = getEntityDependantViews(model)
+	const modifications: Migration.Modification[] = []
+	const removeCascade = (entity: Model.Entity) => {
+		if (removed.has(entity.name)) {
+			return
+		}
+		removed.add(entity.name)
+		for (const dependant of dependants.get(entity.name) ?? []) {
+			removeCascade(dependant)
+		}
+		if (entity.view) {
+			modifications.push(removeEntityModification.createModification({ entityName: entity.name }))
+		}
+	}
+	for (const entity of entities) {
+		removeCascade(entity)
+	}
+	return modifications
+}

package/src/modifications/validation/PatchValidationSchemaModification.ts

@@ -1,11 +1,10 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, ModificationHandler } from '../ModificationHandler'
 import { applyPatch, Operation } from 'rfc6902'
 import deepCopy from '../../utils/deepCopy'
 
-export const PatchValidationSchemaModification: ModificationHandlerStatic<PatchValidationSchemaModificationData> = class {
-	static id = 'patchValidationSchema'
+export class PatchValidationSchemaModificationHandler implements ModificationHandler<PatchValidationSchemaModificationData> {
 	constructor(private readonly data: PatchValidationSchemaModificationData) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -28,12 +27,13 @@ export const PatchValidationSchemaModification: ModificationHandlerStatic<PatchV
 	describe() {
 		return { message: 'Update validation schema' }
 	}
-
-	static createModification(data: PatchValidationSchemaModificationData) {
-		return { modification: this.id, ...data }
-	}
 }
 
 export interface PatchValidationSchemaModificationData {
 	patch: Operation[]
 }
+
+export const patchValidationSchemaModification = createModificationType({
+	id: 'patchValidationSchema',
+	handler: PatchValidationSchemaModificationHandler,
+})

package/src/modifications/validation/UpdateValidationSchemaModification.ts

@@ -1,13 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema, Validation } from '@contember/schema'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createPatch } from 'rfc6902'
-import { PatchValidationSchemaModification } from './PatchValidationSchemaModification'
+import { patchValidationSchemaModification } from './PatchValidationSchemaModification'
 
-export const UpdateValidationSchemaModification: ModificationHandlerStatic<UpdateValidationSchemaModificationData> = class {
-	static id = 'updateValidationSchema'
+export class UpdateValidationSchemaModificationHandler implements ModificationHandler<UpdateValidationSchemaModificationData> {
 	constructor(private readonly data: UpdateValidationSchemaModificationData) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -23,22 +22,26 @@ export const UpdateValidationSchemaModification: ModificationHandlerStatic<Updat
 		return { message: 'Update validation schema' }
 	}
 
-	static createModification(data: UpdateValidationSchemaModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
+
+export interface UpdateValidationSchemaModificationData {
+	schema: Validation.Schema
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateValidationSchemaModification = createModificationType({
+	id: 'updateValidationSchema',
+	handler: UpdateValidationSchemaModificationHandler,
+})
+
+export class UpdateValidationSchemaDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		if (deepEqual(originalSchema.validation, updatedSchema.validation)) {
 			return []
 		}
 		const patch = createPatch(originalSchema.validation, updatedSchema.validation)
 		if (patch.length <= 20) {
-			return [PatchValidationSchemaModification.createModification({ patch })]
+			return [patchValidationSchemaModification.createModification({ patch })]
 		}
-		return [UpdateValidationSchemaModification.createModification({ schema: updatedSchema.validation })]
+		return [updateValidationSchemaModification.createModification({ schema: updatedSchema.validation })]
 	}
 }
-
-export interface UpdateValidationSchemaModificationData {
-	schema: Validation.Schema
-}

package/src/tsconfig.json

@@ -7,10 +7,10 @@
 	},
 	"references": [
 		{
-			"path": "../../database-migrations/src"
+			"path": "../../database/src"
 		},
 		{
-			"path": "../../engine-common/src"
+			"path": "../../database-migrations/src"
 		},
 		{
 			"path": "../../schema/src"

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

@@ -64,9 +64,10 @@ testMigrations('convert one has many to many has many', {
 	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")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "article_categories"
+		ADD 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

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

@@ -35,3 +35,36 @@ UPDATE "author" SET "name" = $pga$unnamed author$pga$;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
 })
+
+testMigrations('create a column with copy value', {
+	originalSchema: def.createModel({
+		Author: class Author {
+			email = def.stringColumn().unique()
+		},
+	}),
+	updatedSchema: def.createModel({
+		Author: class Author {
+			name = def.stringColumn().notNull()
+			email = def.stringColumn().unique()
+		},
+	}),
+	diff: [
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'name',
+				name: 'name',
+				nullable: false,
+				type: Model.ColumnType.String,
+				columnType: 'text',
+			},
+			copyValue: 'email',
+		},
+	],
+	noDiff: true,
+	sql: SQL`ALTER TABLE "author" ADD "name" text;
+UPDATE "author" SET "name" = "email"::text;
+SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
+ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
+})

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

@@ -90,9 +90,10 @@ testMigrations('create many has many relation (post with categories)', {
 		ADD "title" text;
 	CREATE TABLE "post_categories" (
 		"post_id"     uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
-		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE,
-		CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "post_categories"
+		ADD CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id");
 	CREATE TRIGGER "log_event"
 		AFTER INSERT OR UPDATE OR DELETE
 		ON "post_categories"

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

@@ -86,3 +86,73 @@ testMigrations('create view', {
 	sql: SQL`CREATE VIEW "author_stats" AS SELECT 1;`,
 })
 
+
+namespace ViewAddRelationOriginalSchema {
+	export class Article {
+		title = def.stringColumn()
+	}
+
+
+	export class Category {
+		name = def.stringColumn()
+	}
+}
+
+namespace ViewAddRelationUpdateSchema {
+	export class Article {
+		title = def.stringColumn()
+		category = def.manyHasOne(Category)
+		stats = def.oneHasOneInverse(ArticleStats, 'article')
+	}
+
+	export class Category {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT 1')
+	export class ArticleStats {
+		article = def.oneHasOne(Article, 'stats')
+		visitCount = def.intColumn()
+	}
+}
+
+
+testMigrations('create a relation and a view', {
+	originalSchema: def.createModel(ViewAddRelationOriginalSchema), updatedSchema: def.createModel(ViewAddRelationUpdateSchema), diff: [
+		{
+			modification: 'createRelation',
+			entityName: 'Article',
+			owningSide: { name: 'category', nullable: true, type: 'ManyHasOne', target: 'Category', joiningColumn: { columnName: 'category_id', onDelete: 'restrict' } },
+		},
+		{
+			modification: 'createView',
+			entity: { name: 'ArticleStats',
+				primary: 'id',
+				primaryColumn: 'id',
+				unique: {},
+				indexes: {},
+				fields: { id: { name: 'id', columnName: 'id', nullable: false, type: 'Uuid', columnType: 'uuid' },
+					article: { name: 'article', inversedBy: 'stats', nullable: true, type: 'OneHasOne', target: 'Article', joiningColumn: { columnName: 'article_id', onDelete: 'restrict' } },
+					visitCount: { name: 'visitCount', columnName: 'visit_count', nullable: true, type: 'Integer', columnType: 'integer' } },
+				tableName: 'article_stats',
+				eventLog: { enabled: true },
+				view: { sql: 'SELECT 1' } },
+		},
+		{
+			modification: 'createRelationInverseSide',
+			entityName: 'Article',
+			relation: {
+				name: 'stats',
+				ownedBy: 'article',
+				target: 'ArticleStats',
+				type: 'OneHasOne',
+				nullable: true,
+			},
+		},
+	],
+	sql: SQL`ALTER TABLE "article" ADD "category_id" uuid; 
+ALTER TABLE "article" ADD CONSTRAINT "fk_article_category_id_703b8b" FOREIGN KEY ("category_id") REFERENCES "category"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE; 
+CREATE INDEX "article_category_id_index" ON "article" ("category_id"); 
+CREATE VIEW "article_stats" AS SELECT 1;`,
+})
+

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

@@ -2,6 +2,8 @@ import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
 
 testMigrations('remove relation (many has one)', {
 	originalSchema: new SchemaBuilder()
@@ -128,3 +130,59 @@ testMigrations('remove relation inverse side', {
 	],
 	sql: SQL``,
 })
+
+
+namespace DropIndexOrigSchema {
+
+	@def.Unique('title', 'author')
+	@def.Index('title', 'author')
+	export class Article {
+		title = def.stringColumn()
+		author = def.manyHasOne(Author)
+	}
+
+	export class Author {
+		name = def.stringColumn()
+	}
+}
+
+namespace DropIndexUpSchema {
+	@def.Unique('title', 'author')
+	@def.Index('title', 'author')
+	export class Article {
+		title = def.stringColumn()
+		author = def.stringColumn()
+	}
+
+	export class Author {
+		name = def.stringColumn()
+	}
+}
+
+
+testMigrations('test drop index / unique when removing a field', {
+	originalSchema: def.createModel(DropIndexOrigSchema),
+	updatedSchema: def.createModel(DropIndexUpSchema),
+	diff: [{
+		modification: 'removeField',
+		entityName: 'Article',
+		fieldName: 'author',
+	}, {
+		modification: 'createColumn',
+		entityName: 'Article',
+		field: { name: 'author', columnName: 'author', nullable: true, type: 'String', columnType: 'text' },
+	}, {
+		modification: 'createUniqueConstraint',
+		entityName: 'Article',
+		unique: { name: 'unique_Article_title_author_7157ea', fields: ['title', 'author'] },
+	}, {
+		modification: 'createIndex',
+		entityName: 'Article',
+		index: { name: 'idx_Article_title_author_7157ea', fields: ['title', 'author'] },
+	}],
+	sql: SQL`ALTER TABLE "article" DROP "author_id";
+ALTER TABLE "article" ADD "author" text;
+ALTER TABLE "article" ADD CONSTRAINT "unique_Article_title_author_7157ea" UNIQUE ("title", "author");
+CREATE INDEX "idx_Article_title_author_7157ea" ON "article" ("title", "author");`,
+})
+

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