@contember/engine-system-api 2.0.0-alpha.10 → 2.0.0-alpha.13

package/graphql.codegen.yml

@@ -7,6 +7,8 @@ config:
   scalars:
     DateTime: Date
     Json: unknown
+    PrimaryKey: "string | number"
+    ContentSchema: unknown
 generates:
   ./src/schema/types.ts:
     config:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "2.0.0-alpha.10",
+  "version": "2.0.0-alpha.13",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -26,21 +26,21 @@
     "generate": "gql-gen --config graphql.codegen.yml"
   },
   "dependencies": {
-    "@contember/authorization": "2.0.0-alpha.10",
-    "@contember/database": "2.0.0-alpha.10",
-    "@contember/database-migrations": "2.0.0-alpha.10",
-    "@contember/dic": "2.0.0-alpha.10",
-    "@contember/graphql-utils": "2.0.0-alpha.10",
-    "@contember/logger": "2.0.0-alpha.10",
-    "@contember/queryable": "2.0.0-alpha.10",
-    "@contember/schema": "2.0.0-alpha.10",
-    "@contember/schema-migrations": "2.0.0-alpha.10",
-    "@contember/schema-utils": "2.0.0-alpha.10",
+    "@contember/authorization": "2.0.0-alpha.13",
+    "@contember/database": "2.0.0-alpha.13",
+    "@contember/database-migrations": "2.0.0-alpha.13",
+    "@contember/dic": "2.0.0-alpha.13",
+    "@contember/graphql-utils": "2.0.0-alpha.13",
+    "@contember/logger": "2.0.0-alpha.13",
+    "@contember/queryable": "2.0.0-alpha.13",
+    "@contember/schema": "2.0.0-alpha.13",
+    "@contember/schema-migrations": "2.0.0-alpha.13",
+    "@contember/schema-utils": "2.0.0-alpha.13",
     "@graphql-tools/utils": "^10.0.8",
     "graphql-tag": "^2.12.6"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.0.0-alpha.10",
+    "@contember/schema-definition": "2.0.0-alpha.13",
     "@graphql-codegen/cli": "^5.0.0",
     "@graphql-codegen/typescript": "^4.0.1",
     "@graphql-codegen/typescript-operations": "^4.0.1",

package/src/SystemContainer.ts

@@ -16,7 +16,6 @@ import {
 	PermissionsFactory,
 	ProjectMigrator,
 	ProjectTruncateExecutor,
-	SchemaVersionBuilder,
 } from './model'
 import { UuidProvider } from './utils'
 import {
@@ -31,12 +30,14 @@ import {
 } from './resolvers'
 import { EventOldValuesResolver } from './resolvers/types'
 import { DatabaseMetadataResolver } from '@contember/database'
+import { SchemaProvider } from './model'
+import { SchemaQueryResolver } from './resolvers/query/SchemaQueryResolver'
 
 export interface SystemContainer {
 	systemResolversFactory: ResolverFactory
 	authorizator: Authorizator
 	resolverContextFactory: SystemResolverContextFactory
-	schemaVersionBuilder: SchemaVersionBuilder
+	schemaProvider: SchemaProvider
 }
 
 type Args = {
@@ -58,7 +59,7 @@ export class SystemContainerFactory {
 				'systemResolversFactory',
 				'authorizator',
 				'resolverContextFactory',
-				'schemaVersionBuilder',
+				'schemaProvider',
 			)
 	}
 	public createBuilder({ identityFetcher }: Args) {
@@ -73,8 +74,8 @@ export class SystemContainerFactory {
 				new SchemaMigrator(modificationHandlerFactory))
 			.addService('executedMigrationsResolver', ({}) =>
 				new ExecutedMigrationsResolver())
-			.addService('schemaVersionBuilder', ({ executedMigrationsResolver, schemaMigrator }) =>
-				new SchemaVersionBuilder(executedMigrationsResolver, schemaMigrator))
+			.addService('schemaProvider', ({ executedMigrationsResolver, schemaMigrator }) =>
+				new SchemaProvider(executedMigrationsResolver, schemaMigrator))
 			.addService('accessEvaluator', ({}) =>
 				new AccessEvaluator.PermissionEvaluator(new PermissionsFactory().create()))
 			.addService('authorizator', ({ accessEvaluator }): Authorizator =>
@@ -87,12 +88,12 @@ export class SystemContainerFactory {
 				new DatabaseMetadataResolver())
 			.addService('migrationsDatabaseMetadataResolverStoreFactory', ({ databaseMetadataResolver }) =>
 				new MigrationsDatabaseMetadataResolverStoreFactory(databaseMetadataResolver))
-			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory }) =>
-				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory, this.contentQueryExecutor))
+			.addService('projectMigrator', ({ migrationDescriber, schemaProvider, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory }) =>
+				new ProjectMigrator(migrationDescriber, schemaProvider, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory, this.contentQueryExecutor))
 			.addService('projectTruncateExecutor', () =>
 				new ProjectTruncateExecutor())
-			.addService('migrationAlterer', () =>
-				new MigrationAlterer())
+			.addService('migrationAlterer', ({ schemaProvider }) =>
+				new MigrationAlterer(schemaProvider))
 			.addService('eventResponseBuilder', ({ identityFetcher }) =>
 				new EventResponseBuilder(identityFetcher))
 			.addService('stagesQueryResolver', () =>
@@ -109,8 +110,10 @@ export class SystemContainerFactory {
 				new EventsQueryResolver(eventResponseBuilder))
 			.addService('eventOldValuesResolver', () =>
 				new EventOldValuesResolver())
-			.addService('systemResolversFactory', ({ stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver }) =>
-				new ResolverFactory(stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver))
+			.addService('schemaQueryResolver', () =>
+				new SchemaQueryResolver())
+			.addService('systemResolversFactory', ({ stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver, schemaQueryResolver }) =>
+				new ResolverFactory(stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver, schemaQueryResolver))
 			.addService('resolverContextFactory', ({ authorizator }) =>
 				new SystemResolverContextFactory(authorizator))
 	}

package/src/bin/runMigrations.ts

@@ -1,6 +1,6 @@
 import { SystemMigrationsRunner } from '../migrations'
-import { DatabaseContextFactory, emptyVersionedSchema, SchemaVersionBuilder } from '../model'
-import { Connection, DatabaseMetadataResolver, emptyDatabaseMetadata } from '@contember/database'
+import { DatabaseContextFactory, emptyVersionedSchema, SchemaProvider } from '../model'
+import { DatabaseMetadataResolver, emptyDatabaseMetadata } from '@contember/database'
 import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 
 
@@ -20,8 +20,8 @@ import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 		}),
 		{ db: dbConfig, slug: 'test', stages: [], systemSchema: 'system' },
 		{
-			buildSchema: () => Promise.resolve(emptyVersionedSchema),
-		} as unknown as SchemaVersionBuilder,
+			buildSchemaFromMigrations: () => Promise.resolve(emptyVersionedSchema),
+		} as unknown as SchemaProvider,
 		{},
 		{
 			resolveMetadata: () => Promise.resolve(emptyDatabaseMetadata),

package/src/index.ts

@@ -16,12 +16,13 @@ export {
 	LatestTransactionIdByStageQuery,
 	ProjectInitializer,
 	ProjectMigrator,
-	SchemaVersionBuilder,
 	type Stage,
 	StageBySlugQuery,
 	StageCreator,
 	StagesQuery,
-	type VersionedSchema,
+	SchemaProvider,
+	type SchemaMeta,
+	type SchemaWithMeta,
 } from './model'
 export * from './SystemContainer'
 export * from './resolvers'

package/src/migrations/2020-05-06-150000-composed-primary.ts

@@ -58,7 +58,7 @@ const migrateEvents = (builder: MigrationBuilder, tableName: string, primaryKeys
 }
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const tablesToMigrate = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	for (const table of tablesToMigrate) {

package/src/migrations/2020-06-01-103000-event-trigger-perf.ts

@@ -16,7 +16,7 @@ const createEventStatementTrigger = (builder: MigrationBuilder, tableName: Name)
 }
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	builder.sql(`CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$

package/src/migrations/2021-05-07-155800-event-log-rework.ts

@@ -18,7 +18,7 @@ const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 }
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 	builder.sql(`LOCK TABLE event`)

package/src/migrations/2021-05-19-1232000-event-log-fix-constraint.ts

@@ -21,7 +21,7 @@ const recreateTrigger = (builder: MigrationBuilder, tableName: Name) => {
 }
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const junctionTables = getJunctionTables(schema.model)
 	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 

package/src/migrations/2022-10-03-110000-table-on-delete.ts

@@ -5,7 +5,7 @@ import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const stages = (await args.connection.query<{schema: string}>('SELECT schema FROM stage')).rows
 	const metadataByStage: Record<string, DatabaseMetadata> = {}
 

package/src/migrations/2023-09-11-174000-fix-on-delete.ts

@@ -5,7 +5,7 @@ import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const stages = (await args.connection.query<{schema: string}>('SELECT schema FROM stage')).rows
 	const metadataByStage: Record<string, DatabaseMetadata> = {}
 

package/src/migrations/2023-10-19-173000-fix-unique.ts

@@ -4,7 +4,7 @@ import { SystemMigrationArgs } from './types'
 import { getUniqueConstraintColumns } from '@contember/schema-migrations'
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
-	const schema = await args.schemaResolver(args.connection)
+	const schema = (await args.schemaResolver(args.connection)).schema
 	const stages = (await args.connection.query<{schema: string}>('SELECT schema FROM stage')).rows
 	const metadataByStage: Record<string, DatabaseMetadata> = {}
 

package/src/migrations/2024-06-28-153000-schema.ts

@@ -0,0 +1,20 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+// deliberately using "JSON" instead of "JSONB" to preserve the order of keys
+
+const sql = `
+CREATE TYPE SCHEMA_SINGLE AS ENUM ('single');
+CREATE TABLE "schema"
+(
+	id         SCHEMA_SINGLE NOT NULL PRIMARY KEY DEFAULT 'single',
+	schema     JSON          NOT NULL,
+	updated_at TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
+	checksum   CHAR(32)      NOT NULL,
+	version    VARCHAR(20)   NOT NULL,
+	migration_id INT         NOT NULL REFERENCES schema_migration(id) DEFERRABLE INITIALLY DEFERRED
+);
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/2024-06-28-153001-schema-init.ts

@@ -0,0 +1,12 @@
+import { escapeValue, MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
+import { SystemMigrationArgs } from './types'
+
+
+export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
+	const schema = await args.schemaResolver(args.connection)
+	if (!schema.meta.id) {
+		return
+	}
+	builder.sql(`INSERT INTO schema(schema, checksum, version, migration_id) 
+VALUES(${escapeValue(JSON.stringify(schema))}, ${escapeValue(schema.meta.checksum)}, ${escapeValue(schema.meta.version)}, ${schema.meta.id})`)
+}

package/src/migrations/2024-07-29-150000-event-data-index.ts

@@ -0,0 +1,11 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+CREATE INDEX IF NOT EXISTS system_event_data_row_id_0 ON event_data USING btree ((row_ids -> 0));
+CREATE INDEX IF NOT EXISTS system_event_data_row_id_1 ON event_data USING btree ((row_ids -> 1));
+DROP INDEX IF EXISTS system_event_row_id;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/runner.ts

@@ -26,10 +26,13 @@ import _20230911174000fixondelete from './2023-09-11-174000-fix-on-delete'
 import _20231019173000fixunique from './2023-10-19-173000-fix-unique'
 import _20231024140000schemanullablechecksum from './2023-10-24-140000-schema-nullable-checksum'
 import _20240628150000migrationsdropsequence from './2024-06-28-150000-migrations-drop-sequence'
+import _20240628153000schema from './2024-06-28-153000-schema'
+import _20240628153001schemainit from './2024-06-28-153001-schema-init'
+import _20240729150000eventdataindex from './2024-07-29-150000-event-data-index'
 import snapshot from './snapshot'
 
 import { Connection, createDatabaseIfNotExists, DatabaseConfig, DatabaseMetadataResolver } from '@contember/database'
-import { DatabaseContextFactory, SchemaVersionBuilder } from '../model'
+import { DatabaseContextFactory, SchemaProvider } from '../model'
 import { ProjectConfig } from '../types'
 import { Logger } from '@contember/logger'
 
@@ -56,6 +59,9 @@ const migrations = {
 	'2023-10-19-173000-fix-unique': _20231019173000fixunique,
 	'2023-10-24-140000-schema-nullable-checksum': _20231024140000schemanullablechecksum,
 	'2024-06-28-150000-migrations-drop-sequence': _20240628150000migrationsdropsequence,
+	'2024-06-28-153000-schema': _20240628153000schema,
+	'2024-06-28-153001-schema-init': _20240628153001schemainit,
+	'2024-07-29-150000-event-data-index': _20240729150000eventdataindex,
 }
 
 
@@ -63,7 +69,7 @@ export class SystemMigrationsRunner {
 	constructor(
 		private readonly databaseContextFactory: DatabaseContextFactory,
 		private readonly project: ProjectConfig & { db: DatabaseConfig },
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly schemaProvider: SchemaProvider,
 		private readonly migrationGroups: Record<string, MigrationGroup<unknown>>,
 		private readonly databaseMetadataResolver: DatabaseMetadataResolver,
 	) {
@@ -72,9 +78,9 @@ export class SystemMigrationsRunner {
 		await createDatabaseIfNotExists(this.project.db, message => typeof message === 'string' ? logger.warn(message) : logger.error(message))
 		const singleConnection = Connection.createSingle(this.project.db, err => logger.error(err))
 		await singleConnection.scope(async connection => {
-			const schemaResolver = (connection: Connection.ConnectionLike) => {
+			const schemaResolver = async (connection: Connection.ConnectionLike) => {
 				const dbContextMigrations = this.databaseContextFactory.create(connection)
-				return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
+				return await this.schemaProvider.buildSchemaFromMigrations(dbContextMigrations)
 			}
 			const migrationResolver = new GroupMigrationsResolver(
 				new SnapshotMigrationResolver(snapshot, migrations),

package/src/migrations/snapshot.ts

@@ -8,6 +8,9 @@ CREATE TYPE "schema_migration_type" AS ENUM (
     'schema',
     'content'
 );
+CREATE TYPE "schema_single" AS ENUM (
+    'single'
+);
 CREATE FUNCTION "trigger_event"() RETURNS "trigger"
     LANGUAGE "plpgsql"
     AS $$
@@ -115,6 +118,14 @@ CREATE TABLE "event_data" (
     "identity_id" "uuid" NOT NULL,
     "transaction_id" "uuid" DEFAULT COALESCE((NULLIF("current_setting"('system.transaction_id'::"text", true), ''::"text"))::"uuid", ("set_config"('system.transaction_id'::"text", ("${randomUuidFn}"())::"text", true))::"uuid") NOT NULL
 );
+CREATE TABLE "schema" (
+    "id" "schema_single" DEFAULT 'single'::"schema_single" NOT NULL,
+    "schema" "json" NOT NULL,
+    "updated_at" timestamp with time zone DEFAULT "now"() NOT NULL,
+    "checksum" character(32) NOT NULL,
+    "version" character varying(20) NOT NULL,
+    "migration_id" integer NOT NULL
+);
 CREATE TABLE "schema_migration" (
     "id" integer NOT NULL,
     "version" character varying(20) NOT NULL,
@@ -143,6 +154,8 @@ ALTER TABLE ONLY "schema_migration"
     ADD CONSTRAINT "schema_migration_pkey" PRIMARY KEY ("id");
 ALTER TABLE ONLY "schema_migration"
     ADD CONSTRAINT "schema_migration_version_key" UNIQUE ("version");
+ALTER TABLE ONLY "schema"
+    ADD CONSTRAINT "schema_pkey" PRIMARY KEY ("id");
 ALTER TABLE ONLY "stage"
     ADD CONSTRAINT "stage_pkey" PRIMARY KEY ("id");
 ALTER TABLE ONLY "stage"
@@ -155,11 +168,14 @@ CREATE INDEX "event_data_created" ON "event_data" USING "btree" ("created_at");
 CREATE INDEX "system_event2_table_name" ON "event_data" USING "btree" ("table_name");
 CREATE INDEX "system_event2_transaction" ON "event_data" USING "btree" ("transaction_id");
 CREATE INDEX "system_event2_type" ON "event_data" USING "btree" ("type");
-CREATE INDEX "system_event_row_id" ON "event_data" USING "btree" ("row_ids");
+CREATE INDEX "system_event_data_row_id_0" ON "event_data" USING "btree" ((("row_ids" -> 0)));
+CREATE INDEX "system_event_data_row_id_1" ON "event_data" USING "btree" ((("row_ids" -> 1)));
 CREATE INDEX "system_schema_migration_version" ON "schema_migration" USING "btree" ("version");
 CREATE INDEX "transaction_applied" ON "stage_transaction" USING "btree" ("applied_at");
 ALTER TABLE ONLY "event_data"
     ADD CONSTRAINT "event_data_schema_id_fkey" FOREIGN KEY ("schema_id") REFERENCES "schema_migration"("id");
+ALTER TABLE ONLY "schema"
+    ADD CONSTRAINT "schema_migration_id_fkey" FOREIGN KEY ("migration_id") REFERENCES "schema_migration"("id") DEFERRABLE INITIALLY DEFERRED;
 ALTER TABLE ONLY "stage_transaction"
     ADD CONSTRAINT "stage_transaction_stage_id_fkey" FOREIGN KEY ("stage_id") REFERENCES "stage"("id") ON DELETE CASCADE;
 `)

package/src/migrations/types.ts

@@ -1,9 +1,9 @@
-import { Schema } from '@contember/schema'
 import { ProjectConfig } from '../types'
 import { Connection, DatabaseMetadata } from '@contember/database'
+import { SchemaWithMeta } from '../model'
 
 export interface SystemMigrationArgs {
-	schemaResolver: (connection: Connection.ConnectionLike) => Promise<Schema>
+	schemaResolver: (connection: Connection.ConnectionLike) => Promise<SchemaWithMeta>
 	databaseMetadataResolver: (connection: Connection.ConnectionLike, schema: string) => Promise<DatabaseMetadata>
 	project: ProjectConfig
 }

package/src/model/SchemaGetter.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@contember/schema'
+
+export type SchemaGetter = (options?: { normalize?: boolean; stage?: string }) => Promise<Schema>

package/src/model/authorization/AuthorizationActions.ts

@@ -9,4 +9,5 @@ export namespace AuthorizationActions {
 
 	export const PROJECT_MIGRATE = Authorizator.createAction(Resources.project, 'migrate')
 	export const PROJECT_LIST_MIGRATIONS = Authorizator.createAction(Resources.project, 'listMigrations')
+	export const PROJECT_SHOW_SCHEMA = Authorizator.createAction(Resources.project, 'showSchema')
 }

package/src/model/authorization/PermissionsFactory.ts

@@ -8,6 +8,7 @@ export class PermissionsFactory {
 		permissions.allow(ProjectRole.ADMIN, { resource: Permissions.ALL, privilege: Permissions.ALL })
 		permissions.allow(ProjectRole.DEPLOYER, AuthorizationActions.PROJECT_MIGRATE)
 		permissions.allow(ProjectRole.DEPLOYER, AuthorizationActions.PROJECT_LIST_MIGRATIONS)
+		permissions.allow(ProjectRole.DEPLOYER, AuthorizationActions.PROJECT_SHOW_SCHEMA)
 
 		return permissions
 	}

package/src/model/authorization/StagePermissionsFactory.ts

@@ -1,15 +1,15 @@
-import { Acl, Schema } from '@contember/schema'
+import { Acl } from '@contember/schema'
 import { Permissions } from '@contember/authorization'
-import { filterSchemaByStage } from '@contember/schema-utils'
 import { AuthorizationActions } from './AuthorizationActions'
+import { SchemaGetter } from '../SchemaGetter'
 
 export class StagePermissionsFactory {
-	constructor(private readonly schema: Schema) {}
+	constructor(private readonly getSchema: SchemaGetter) {}
 
-	public create(stage: string): Permissions {
+	public async create(stage: string): Promise<Permissions> {
 		const permissions = new Permissions()
 
-		const filteredSchema = filterSchemaByStage(this.schema, stage)
+		const filteredSchema = await this.getSchema({ stage })
 
 		const rolePermissions = this.createRolePermissions(filteredSchema.acl)
 		Object.entries(rolePermissions).forEach(([role, value]) => {

package/src/model/authorization/StageScope.ts

@@ -6,8 +6,8 @@ import { StagePermissionsFactory } from './StagePermissionsFactory'
 export class StageScope implements AuthorizationScope<Identity> {
 	constructor(private readonly stage: string, private readonly stagePermissionsFactory: StagePermissionsFactory) {}
 
-	getIdentityAccess(identity: Identity): Promise<AccessNode> {
-		const permissions = this.stagePermissionsFactory.create(this.stage)
+	async getIdentityAccess(identity: Identity): Promise<AccessNode> {
+		const permissions = await this.stagePermissionsFactory.create(this.stage)
 		const roles = new AccessNode.Roles(identity.roles)
 		const permissionEvaluator = new AccessEvaluator.PermissionEvaluator(permissions)
 		const node = new SwitchEvaluatorNode(roles, permissionEvaluator)

package/src/model/commands/schema/SaveSchemaCommand.ts

@@ -0,0 +1,31 @@
+import { ConflictActionType, InsertBuilder } from '@contember/database'
+import { Command } from '../Command'
+import { SchemaWithMeta } from '../../migrations'
+
+export class SaveSchemaCommand implements Command<void> {
+	constructor(private readonly input: SchemaWithMeta) {}
+
+	public async execute({ db }: Command.Args): Promise<void> {
+		if (!this.input.meta.updatedAt) {
+			throw new Error('Cannot persist empty schema')
+		}
+
+		await InsertBuilder.create()
+			.into('schema')
+			.values({
+				schema: this.input.schema,
+				updated_at: this.input.meta.updatedAt.toISOString(),
+				checksum: this.input.meta.checksum,
+				version: this.input.meta.version,
+				migration_id: this.input.meta.id,
+			})
+			.onConflict(ConflictActionType.update, ['id'], {
+				schema: expr => expr.select(['excluded', 'schema']),
+				updated_at: expr => expr.select(['excluded', 'updated_at']),
+				checksum: expr => expr.select(['excluded', 'checksum']),
+				version: expr => expr.select(['excluded', 'version']),
+				migration_id: expr => expr.select(['excluded', 'migration_id']),
+			})
+			.execute(db)
+	}
+}

package/src/model/dependencies/content/ContentQueryExecutor.ts

@@ -1,11 +1,12 @@
 import { Stage } from '../../dtos'
 import { DatabaseContext } from '../../database'
-import { Schema } from '@contember/schema'
 import { ExecutionResult } from 'graphql'
 import { DatabaseMetadata } from '@contember/database'
+import { Schema } from '@contember/schema'
 
 export interface ContentQueryExecutorContext {
-	schema: Schema & { id: number }
+	schema: Schema
+	schemaMeta: { id: number }
 	identity: { id: string }
 	db: DatabaseContext
 	stage: Stage

package/src/model/migrations/MigrationAlterer.ts

@@ -3,8 +3,15 @@ import { DeleteMigrationCommand } from '../commands'
 import { Response, ResponseError, ResponseOk } from '../../utils'
 import { Migration } from '@contember/schema-migrations'
 import { ModifyMigrationCommand } from '../commands/migrations/ModifyMigrationCommand'
+import { SchemaProvider } from './SchemaProvider'
+import { SaveSchemaCommand } from '../commands/schema/SaveSchemaCommand'
 
 export class MigrationAlterer {
+	constructor(
+		private readonly schemaProvider: SchemaProvider,
+	) {
+	}
+
 	public async deleteMigration(
 		db: DatabaseContext,
 		version: string,
@@ -15,6 +22,7 @@ export class MigrationAlterer {
 				await db.client.connection.rollback()
 				return new ResponseError(DeleteMigrationErrorCode.notFound, `Migration ${version} was not found`)
 			}
+			await this.refreshSchema(db)
 			return new ResponseOk(undefined)
 		})
 	}
@@ -30,9 +38,15 @@ export class MigrationAlterer {
 				await db.client.connection.rollback()
 				return new ResponseError(UpdateMigrationErrorCode.notFound, `Migration ${version} was not found`)
 			}
+			await this.refreshSchema(db)
 			return new ResponseOk(undefined)
 		})
 	}
+
+	private async refreshSchema(db: DatabaseContext): Promise<void> {
+		const schemaWithMeta = await this.schemaProvider.buildSchemaFromMigrations(db)
+		await db.commandBus.execute(new SaveSchemaCommand(schemaWithMeta))
+	}
 }
 
 export enum DeleteMigrationErrorCode {

package/src/model/migrations/ProjectMigrator.ts

@@ -6,17 +6,19 @@ import { Stage } from '../dtos'
 import { DatabaseContext } from '../database'
 import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
-import { SchemaVersionBuilder } from './SchemaVersionBuilder'
-import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
+import { calculateSchemaChecksum, SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
 import { MigrationsDatabaseMetadataResolverStoreFactory, SchemaDatabaseMetadataResolverStore } from '../metadata'
 import { ContentMigrationQuery, MigrationInput } from './MigrationInput'
 import { ContentQueryExecutor } from '../dependencies'
+import { SchemaProvider } from './SchemaProvider'
+import { SaveSchemaCommand } from '../commands/schema/SaveSchemaCommand'
+import { ImplementationException } from '../../utils'
 
 export class ProjectMigrator {
 	constructor(
 		private readonly migrationDescriber: MigrationDescriber,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly schemaProvider: SchemaProvider,
 		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
 		private readonly migrationsDatabaseMetadataResolverStoreFactory: MigrationsDatabaseMetadataResolverStoreFactory,
 		private readonly contentQueryExecutor: ContentQueryExecutor,
@@ -36,8 +38,14 @@ export class ProjectMigrator {
 		if (migrationsToExecute.length === 0) {
 			return
 		}
-		let { version, notNormalized, id, ...schema }  = await this.schemaVersionBuilder.buildSchema(db)
-		const validated = await this.validateMigrations(db, schema, version, migrationsToExecute, { ignoreOrder, skipExecuted })
+		const schemaWithMeta = await this.schemaProvider.fetch({ db })
+		let schema = schemaWithMeta.schema
+		let id = schemaWithMeta.meta.id
+
+		const validated = await this.validateMigrations(db, schema, schemaWithMeta.meta.version ?? null, migrationsToExecute, { ignoreOrder, skipExecuted })
+		if (validated.length === 0) {
+			return
+		}
 
 		const sorted = [...validated].sort((a, b) => a.version.localeCompare(b.version))
 
@@ -61,16 +69,16 @@ export class ProjectMigrator {
 					)
 				}
 			} else if (migration.type === 'content') {
-				const schemaWithId = {
-					...schema,
-					id,
+				if (!id) {
+					throw new FailedContentMigrationError(migration.version, `Cannot execute content migration without schema`)
 				}
 				for (const query of migration.queries) {
 					await this.executeContentMigration({
 						version: migration.version,
 						query,
 						db,
-						schema: schemaWithId,
+						schema,
+						schemaMeta: { id },
 						stages,
 						databaseMetadata: await metadataStore.getMetadata(db.client.schema),
 						identity,
@@ -84,6 +92,19 @@ export class ProjectMigrator {
 			}
 			id = await db.commandBus.execute(new SaveMigrationCommand(migration))
 		}
+		if (!id) {
+			throw new ImplementationException()
+		}
+
+		await db.commandBus.execute(new SaveSchemaCommand({
+			schema,
+			meta: {
+				id,
+				updatedAt: new Date(),
+				version: sorted[sorted.length - 1].version,
+				checksum: calculateSchemaChecksum(schema),
+			},
+		}))
 	}
 
 	private async executeContentMigration({ query, stages, version, ...ctx }: {
@@ -91,7 +112,8 @@ export class ProjectMigrator {
 		db: DatabaseContext
 		query: ContentMigrationQuery
 		stages: Stage[]
-		schema: Schema & { id: number }
+		schema: Schema
+		schemaMeta: { id: number }
 		project: { slug: string; systemSchema: string }
 		identity: { id: string }
 		databaseMetadata: DatabaseMetadata
@@ -120,7 +142,7 @@ export class ProjectMigrator {
 	private async validateMigrations(
 		db: DatabaseContext,
 		schema: Schema,
-		version: string,
+		version: string | null,
 		migrationsToExecute: readonly MigrationInput[],
 		{ ignoreOrder, skipExecuted }: {
 			ignoreOrder: boolean
@@ -140,7 +162,7 @@ export class ProjectMigrator {
 				}
 			}
 
-			if (migration.version < version && !ignoreOrder) {
+			if (version && migration.version < version && !ignoreOrder) {
 				throw new MustFollowLatestMigrationError(migration.version, `Must follow latest executed migration ${version}`)
 			}
 			if (migration.type === 'schema') {