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

package/src/model/migrations/SchemaProvider.ts

@@ -0,0 +1,77 @@
+import { SchemaQuery } from '../queries'
+import { DatabaseContext } from '../database'
+import { calculateSchemaChecksum, emptySchema, normalizeSchema } from '@contember/schema-utils'
+import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
+import { SchemaMigrator } from '@contember/schema-migrations'
+import { Schema } from '@contember/schema'
+
+export type SchemaMeta = {
+	checksum: string
+	version: string
+	updatedAt: Date
+	id: number
+}
+
+export const emptyVersionedSchema: SchemaWithMeta = {
+	schema: emptySchema,
+	meta: {},
+}
+
+export type SchemaWithMeta = {
+	schema: Schema
+	meta: SchemaMeta | { [K in keyof SchemaMeta]?: undefined }
+}
+
+export class SchemaProvider {
+	constructor(
+		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
+		private readonly schemaMigrator: SchemaMigrator,
+	) {
+	}
+
+	async buildSchemaFromMigrations(db: DatabaseContext): Promise<SchemaWithMeta> {
+		const newMigrations = (await this.executedMigrationsResolver.getMigrations(db))
+
+		const partialResult = newMigrations.reduce<SchemaWithMeta>(
+			(schema, migration) => {
+				if (migration.type !== 'schema') {
+					return schema
+				}
+				return {
+					schema: this.schemaMigrator.applyModifications(schema.schema, migration.modifications, migration.formatVersion),
+					meta: {
+						version: migration.version,
+						id: migration.id,
+						updatedAt: migration.executedAt,
+						checksum: '',
+					},
+				}
+			},
+			emptyVersionedSchema,
+		)
+
+		if (!partialResult.meta.version) {
+			return emptyVersionedSchema
+		}
+
+		return {
+			schema: partialResult.schema,
+			meta: {
+				...partialResult.meta,
+				checksum: calculateSchemaChecksum(partialResult.schema),
+			},
+		}
+	}
+
+	public async fetch({ db, currentSchema  }: {
+		db: DatabaseContext
+		currentSchema?: SchemaWithMeta | null
+	}): Promise<SchemaWithMeta> {
+		const newSchema = await db.queryHandler.fetch(new SchemaQuery(currentSchema?.meta.checksum))
+		if (!newSchema) {
+			return currentSchema ?? emptyVersionedSchema
+		}
+
+		return newSchema
+	}
+}

package/src/model/migrations/index.ts

@@ -1,4 +1,4 @@
 export * from './ExecutedMigrationsResolver'
 export * from './MigrationAlterer'
 export * from './ProjectMigrator'
-export * from './SchemaVersionBuilder'
+export * from './SchemaProvider'

package/src/model/queries/events/EventsQuery.ts

@@ -2,6 +2,7 @@ import {
 	ConditionBuilder,
 	DatabaseQuery,
 	DatabaseQueryable,
+	Literal,
 	Operator,
 	SelectBuilder,
 	SelectBuilderSpecification, Value,
@@ -78,23 +79,20 @@ export class EventsQuery extends DatabaseQuery<ContentEvent[]> {
 				if (!this.filter.rows) {
 					return qb
 				}
-				type PrimaryKey = readonly string[]
-				const byTable: Record<string, PrimaryKey[]> = {}
-				for (const row of this.filter.rows) {
-					byTable[row.tableName] ??= []
-					byTable[row.tableName].push(row.primaryKey)
-				}
-				const rowFilters = Object.entries(byTable)
-				const ors = rowFilters.reduce(
-					(expr, [table, rowIds]) =>
-						expr.and(
-							ConditionBuilder.create()
-								.compare('table_name', Operator.eq, table)
-								.in('row_ids', rowIds.map(it => JSON.stringify(it))),
-						),
-					ConditionBuilder.create(),
-				)
-				return qb.where(ConditionBuilder.create().or(ors))
+
+				const ors: Literal[] = this.filter.rows.map(row => {
+					const builder = ConditionBuilder.create()
+						.compare('table_name', Operator.eq, row.tableName)
+
+					return row.primaryKey.reduce((expr, val, index) => {
+						if (val === null) {
+							return expr
+						}
+						return expr.raw(`"row_ids"->${index} = ?::jsonb`, JSON.stringify(val))
+					}, builder).getSql()
+				}).filter((it): it is Literal => it !== null)
+
+				return qb.where(ConditionBuilder.create().or(ConditionBuilder.create(ors)))
 			})
 
 			.limit(this.limit, this.offset)

package/src/model/queries/index.ts

@@ -1,3 +1,4 @@
 export * from './migrations'
 export * from './events'
 export * from './stages'
+export * from './schema'

package/src/model/queries/schema/SchemaQuery.ts

@@ -0,0 +1,48 @@
+import { DatabaseQuery, DatabaseQueryable, Literal, SelectBuilder } from '@contember/database'
+import { Schema } from '@contember/schema'
+import { SchemaWithMeta } from '../../migrations'
+
+export class SchemaQuery extends DatabaseQuery<SchemaWithMeta | null> {
+
+	constructor(
+		private readonly currentHash?: string,
+	) {
+		super()
+	}
+
+
+	async fetch(queryable: DatabaseQueryable): Promise<SchemaWithMeta | null> {
+		const query = SelectBuilder.create<{
+			schema: Schema
+			checksum: string
+			version: string
+			updated_at: Date
+			migration_id: number
+		}>()
+			.from('schema')
+			.select(new Literal('*'))
+			.where({
+				id: 'single',
+			})
+			.match(it => {
+				if (!this.currentHash) {
+					return it
+				}
+				return it.where(it => it.raw('checksum != ?', this.currentHash))
+			})
+
+		const row =  this.fetchOneOrNull(await query.getResult(queryable.db))
+		if (!row) {
+			return null
+		}
+		return {
+			schema: row.schema,
+			meta: {
+				checksum: row.checksum,
+				version: row.version,
+				updatedAt: row.updated_at,
+				id: row.migration_id,
+			},
+		}
+	}
+}

package/src/model/queries/schema/index.ts

@@ -0,0 +1 @@
+export * from './SchemaQuery'

package/src/resolvers/ResolverFactory.ts

@@ -2,9 +2,10 @@ import { EventsQueryResolver, ExecutedMigrationsQueryResolver, StagesQueryResolv
 import { Event, EventType, Resolvers } from '../schema'
 import { assertNever } from '../utils'
 import { MigrateMutationResolver, MigrationAlterMutationResolver, TruncateMutationResolver } from './mutation'
-import { DateTimeType, JSONType } from '@contember/graphql-utils'
+import { DateTimeType, JSONType, createJsonLikeType } from '@contember/graphql-utils'
 import { EventOldValuesResolver } from './types'
 import { GraphQLError, GraphQLScalarType, Kind } from 'graphql'
+import { SchemaQueryResolver } from './query/SchemaQueryResolver'
 
 export class ResolverFactory {
 	public constructor(
@@ -15,6 +16,7 @@ export class ResolverFactory {
 		private readonly migrationAlterMutationResolver: MigrationAlterMutationResolver,
 		private readonly eventsQueryResolver: EventsQueryResolver,
 		private readonly eventOldValuesResolver: EventOldValuesResolver,
+		private readonly schemaQueryResolver: SchemaQueryResolver,
 	) {}
 
 	create(debugMode: boolean): Resolvers {
@@ -22,6 +24,7 @@ export class ResolverFactory {
 			DateTime: DateTimeType,
 			Json: JSONType,
 			PrimaryKey: PrimaryKeyType,
+			Schema: SchemaType,
 			Event: {
 				__resolveType: (obj: Event) => {
 					switch (obj.type) {
@@ -43,6 +46,7 @@ export class ResolverFactory {
 				stages: this.stagesQueryResolver.stages.bind(this.stagesQueryResolver),
 				executedMigrations: this.executedMigrationsQueryResolver.executedMigrations.bind(this.executedMigrationsQueryResolver),
 				events: this.eventsQueryResolver.events.bind(this.eventsQueryResolver),
+				schema: this.schemaQueryResolver.schema.bind(this.schemaQueryResolver),
 			},
 			Mutation: {
 				migrate: this.migrateMutationResolver.migrate.bind(this.migrateMutationResolver),
@@ -70,6 +74,10 @@ const parseValue = (value: any)  => {
 	}
 	throw new GraphQLError('PrimaryKey cannot represent value: ' + JSON.stringify(value))
 }
+
+const SchemaType = createJsonLikeType('Schema', 'Content schema custom scalar type')
+
+
 export const PrimaryKeyType = new GraphQLScalarType({
 	name: 'PrimaryKey',
 	description: 'PrimaryKey custom scalar type. Can be Int or String',

package/src/resolvers/SystemResolverContext.ts

@@ -1,31 +1,26 @@
 import { Authorizator } from '@contember/authorization'
-import { Schema } from '@contember/schema'
 import { ForbiddenError } from '@contember/graphql-utils'
-import { DatabaseContext, Identity, VersionedSchema } from '../model'
+import { DatabaseContext, Identity } from '../model'
 import { ProjectConfig } from '../types'
 import { StagePermissionsFactory } from '../model/authorization/StagePermissionsFactory'
 import { StageScope } from '../model/authorization/StageScope'
 import { ItemLoader } from '../utils/batchQuery'
+import { SchemaGetter } from '../model/SchemaGetter'
 
 export class SystemResolverContextFactory {
 	constructor(
 		private readonly authorizator: Authorizator<Identity>,
 	) {}
 
-	public async create(
-		schema: VersionedSchema,
-		systemDbContext: DatabaseContext,
-		project: ProjectConfig,
-		identity: Identity,
-	): Promise<SystemResolverContext> {
-		const stagePermissionsFactory = new StagePermissionsFactory(schema)
+	public async create({ getSchema, identity, project, db }: Pick<SystemResolverContext, 'getSchema' | 'db' | 'identity' | 'project'>): Promise<SystemResolverContext> {
+		const stagePermissionsFactory = new StagePermissionsFactory(getSchema)
 		const loaders = new Map<LoaderFactory<any, any>, ItemLoader<any, any>>()
 		return {
 			project,
 			identity,
-			schema,
+			getSchema,
 			authorizator: this.authorizator,
-			db: systemDbContext,
+			db,
 			requireAccess: async (action, stage, message?) => {
 				if (!(await this.authorizator.isAllowed(identity, new StageScope(stage, stagePermissionsFactory), action))) {
 					throw new ForbiddenError(message || 'Forbidden')
@@ -36,7 +31,7 @@ export class SystemResolverContextFactory {
 				if (loader) {
 					return loader
 				}
-				const newLoader = loaderFactory(systemDbContext)
+				const newLoader = loaderFactory(db)
 				loaders.set(loaderFactory, newLoader)
 				return newLoader
 			},
@@ -48,7 +43,7 @@ export type LoaderFactory<Args, Item> = (db: DatabaseContext) => ItemLoader<Args
 
 export interface SystemResolverContext {
 	readonly project: ProjectConfig
-	readonly schema: Schema
+	readonly getSchema: SchemaGetter
 	readonly identity: Identity
 	readonly db: DatabaseContext
 	readonly authorizator: Authorizator<Identity>

package/src/resolvers/mutation/TruncateMutationResolver.ts

@@ -12,7 +12,7 @@ export class TruncateMutationResolver implements MutationResolver<'truncate'> {
 		context: SystemResolverContext,
 		info: GraphQLResolveInfo,
 	): Promise<TruncateResponse> {
-		await this.projectTruncateExecutor.truncateProject(context.db, context.project, context.schema)
+		await this.projectTruncateExecutor.truncateProject(context.db, context.project, await context.getSchema())
 		return {
 			ok: true,
 		}

package/src/resolvers/query/SchemaQueryResolver.ts

@@ -0,0 +1,19 @@
+import { GraphQLResolveInfo } from 'graphql'
+import { SystemResolverContext } from '../SystemResolverContext'
+import { QueryResolver } from '../Resolver'
+import { AuthorizationActions, StagesQuery } from '../../model'
+
+export class SchemaQueryResolver implements QueryResolver<'schema'> {
+	async schema(
+		parent: any,
+		args: unknown,
+		context: SystemResolverContext,
+		info: GraphQLResolveInfo,
+	) {
+		const stages = await context.db.queryHandler.fetch(new StagesQuery())
+		for (const stage of stages) {
+			await context.requireAccess(AuthorizationActions.PROJECT_SHOW_SCHEMA, stage.slug)
+		}
+		return context.getSchema()
+	}
+}

package/src/schema/system.graphql.ts

@@ -5,6 +5,7 @@ const schema: DocumentNode = gql`
 	scalar DateTime
 	scalar Json
 	scalar PrimaryKey
+	scalar Schema
 
 	schema {
 		query: Query
@@ -15,6 +16,7 @@ const schema: DocumentNode = gql`
 		stages: [Stage!]!
 		executedMigrations(version: String): [ExecutedMigration!]!
 		events(args: EventsArgs): [Event!]!
+		schema: Schema!
 	}
 
 	type Mutation {
@@ -56,7 +58,7 @@ const schema: DocumentNode = gql`
 
 	input EventFilterRow {
 		tableName: String!
-		primaryKey: [PrimaryKey!]!
+		primaryKey: [PrimaryKey]!
 	}
 
 	interface Event {

package/src/schema/types.ts

@@ -14,9 +14,10 @@ export type Scalars = {
 	Boolean: { input: boolean; output: boolean }
 	Int: { input: number; output: number }
 	Float: { input: number; output: number }
+	Schema: { input: any; output: any }
 	DateTime: { input: Date; output: Date }
 	Json: { input: unknown; output: unknown }
-	PrimaryKey: { input: any; output: any }
+	PrimaryKey: { input: string | number; output: string | number }
 }
 
 export type ContentMigration = {
@@ -70,7 +71,7 @@ export type Event = {
 }
 
 export type EventFilterRow = {
-	readonly primaryKey: ReadonlyArray<Scalars['PrimaryKey']['input']>
+	readonly primaryKey: ReadonlyArray<InputMaybe<Scalars['PrimaryKey']['input']>>
 	readonly tableName: Scalars['String']['input']
 }
 
@@ -250,6 +251,7 @@ export type Query = {
 	readonly __typename?: 'Query'
 	readonly events: ReadonlyArray<Event>
 	readonly executedMigrations: ReadonlyArray<ExecutedMigration>
+	readonly schema: Scalars['Schema']['output']
 	readonly stages: ReadonlyArray<Stage>
 }
 
@@ -374,6 +376,7 @@ export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = {
 export type ResolversTypes = {
 	Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>
 	ContentMigration: ContentMigration
+	Schema: ResolverTypeWrapper<Scalars['Schema']['output']>
 	CreateEvent: ResolverTypeWrapper<CreateEvent>
 	DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>
 	DeleteEvent: ResolverTypeWrapper<DeleteEvent>
@@ -415,6 +418,7 @@ export type ResolversTypes = {
 export type ResolversParentTypes = {
 	Boolean: Scalars['Boolean']['output']
 	ContentMigration: ContentMigration
+	Schema: Scalars['Schema']['output']
 	CreateEvent: CreateEvent
 	DateTime: Scalars['DateTime']['output']
 	DeleteEvent: DeleteEvent
@@ -446,6 +450,10 @@ export type ResolversParentTypes = {
 	UpdateEvent: UpdateEvent
 }
 
+export interface SchemaScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Schema'], any> {
+	name: 'Schema'
+}
+
 export type CreateEventResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateEvent'] = ResolversParentTypes['CreateEvent']> = {
 	appliedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
 	createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
@@ -567,6 +575,7 @@ export interface PrimaryKeyScalarConfig extends GraphQLScalarTypeConfig<Resolver
 export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
 	events?: Resolver<ReadonlyArray<ResolversTypes['Event']>, ParentType, ContextType, Partial<QueryEventsArgs>>
 	executedMigrations?: Resolver<ReadonlyArray<ResolversTypes['ExecutedMigration']>, ParentType, ContextType, Partial<QueryExecutedMigrationsArgs>>
+	schema?: Resolver<ResolversTypes['Schema'], ParentType, ContextType>
 	stages?: Resolver<ReadonlyArray<ResolversTypes['Stage']>, ParentType, ContextType>
 }
 
@@ -599,6 +608,7 @@ export type UpdateEventResolvers<ContextType = any, ParentType extends Resolvers
 }
 
 export type Resolvers<ContextType = any> = {
+	Schema?: GraphQLScalarType
 	CreateEvent?: CreateEventResolvers<ContextType>
 	DateTime?: GraphQLScalarType
 	DeleteEvent?: DeleteEventResolvers<ContextType>

package/tests/cases/migrations/2020-05-06-150000-composed-primary.test.ts

@@ -37,7 +37,15 @@ test('many-has-many-primary migration sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve(createSchema(SampleProject)),
+		schemaResolver: () => Promise.resolve({
+			schema: createSchema(SampleProject),
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		}),
 		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',

package/tests/cases/migrations/2020-06-01-103000-event-trigger-perf.test.ts

@@ -37,7 +37,15 @@ test('event-trigger-performance sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve(createSchema(SampleProject)),
+		schemaResolver: () => Promise.resolve({
+			schema: createSchema(SampleProject),
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		}),
 		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',

package/tests/cases/migrations/2022-10-03-110000-table-on-delete.test.ts

@@ -30,12 +30,23 @@ test('table-on-delete test', async () => {
 				deferred: false,
 			}],
 		})),
-		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
-			)
-			.entity('Author', entity => entity)
-			.buildSchema() })),
+		schemaResolver: () => Promise.resolve(({
+			schema: {
+				...emptySchema,
+				model: new SchemaBuilder()
+					.entity('Post', entity =>
+						entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+					)
+					.entity('Author', entity => entity)
+					.buildSchema(),
+			},
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		})),
 		project: {
 			slug: 'test',
 			systemSchema: 'system',

package/tests/cases/migrations/2023-09-11-174000-fix-on-delete.test.ts

@@ -30,12 +30,23 @@ test('table-on-delete test', async () => {
 				deferred: false,
 			}],
 		})),
-		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
-			)
-			.entity('Author', entity => entity)
-			.buildSchema() })),
+		schemaResolver: () => Promise.resolve(({
+			schema: {
+				...emptySchema,
+				model: new SchemaBuilder()
+					.entity('Post', entity =>
+						entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+					)
+					.entity('Author', entity => entity)
+					.buildSchema(),
+			},
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		})),
 		project: {
 			slug: 'test',
 			systemSchema: 'system',
@@ -82,12 +93,21 @@ test('table-on-delete test valid', async () => {
 			}],
 		})),
 		schemaResolver: () => Promise.resolve(({
-			...emptySchema, model: new SchemaBuilder()
-				.entity('Post', entity =>
-					entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
-				)
-				.entity('Author', entity => entity)
-				.buildSchema(),
+			schema: {
+				...emptySchema,
+				model: new SchemaBuilder()
+					.entity('Post', entity =>
+						entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+					)
+					.entity('Author', entity => entity)
+					.buildSchema(),
+			},
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
 		})),
 		project: {
 			slug: 'test',

package/tests/cases/migrations/2023-10-19-173000-fix-unique.test.ts

@@ -45,7 +45,15 @@ test('unique fix test', async () => {
 
 			],
 		})),
-		schemaResolver: () => Promise.resolve(createSchema(UniqueModel)),
+		schemaResolver: () => Promise.resolve({
+			schema: createSchema(UniqueModel),
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		}),
 		project: {
 			slug: 'test',
 			stages: [

package/tests/cases/unit/eventsQuery.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from 'vitest'
+import { EventsQuery } from '../../../src/model'
+import { testUuid } from '../../src/uuid'
+import { EventsOrder } from '../../../src/schema'
+
+test('events query', async () => {
+	const query = new EventsQuery({
+		rows: [
+			{ tableName: 'table1', primaryKey: [testUuid(1)] },
+			{ tableName: 'table2', primaryKey: [testUuid(2), testUuid(3)] },
+			{ tableName: 'table3', primaryKey: [null, testUuid(3)] },
+		],
+	}, EventsOrder.CreatedAtAsc, 0, 10)
+
+	let called = false
+	await query.fetch({
+		db: {
+			schema: 'public',
+			query: async (sql: string, params: any) => {
+				called = true
+				expect(sql).toMatchInlineSnapshot(`"select "id", "type", "table_name", "row_ids", "values", "created_at", "applied_at", "identity_id", "event_data"."transaction_id"  from "public"."event_data" inner join  "public"."stage_transaction" on  "event_data"."transaction_id" = "stage_transaction"."transaction_id"  where ("table_name" = ? and "row_ids"->0 = ?::jsonb or "table_name" = ? and "row_ids"->0 = ?::jsonb and "row_ids"->1 = ?::jsonb or "table_name" = ? and "row_ids"->1 = ?::jsonb)  order by "created_at" asc  limit 10 offset 0"`)
+				expect(params).toMatchInlineSnapshot(`
+					[
+					  "table1",
+					  ""123e4567-e89b-12d3-a456-000000000001"",
+					  "table2",
+					  ""123e4567-e89b-12d3-a456-000000000002"",
+					  ""123e4567-e89b-12d3-a456-000000000003"",
+					  "table3",
+					  ""123e4567-e89b-12d3-a456-000000000003"",
+					]
+				`)
+
+				return { rows: [] }
+			},
+		},
+	} as any)
+	expect(called).toBe(true)
+})

package/tests/src/uuid.ts

@@ -0,0 +1,4 @@
+export const testUuidPrefix = '123e4567-e89b-12d3-'
+export const testUuid = (number: number, prefix = 'a456') => {
+	return testUuidPrefix + prefix + '-' + number.toString().padStart(12, '0')
+}

package/dist/development/src/model/migrations/SchemaVersionBuilder.cjs

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const schemaUtils = require("@contember/schema-utils");
-const emptyVersionedSchema = { ...schemaUtils.normalizeSchema(schemaUtils.emptySchema), version: "", id: -1, notNormalized: { ...schemaUtils.emptySchema, version: "", id: -1 } };
-class SchemaVersionBuilder {
-  constructor(executedMigrationsResolver, schemaMigrator) {
-    this.executedMigrationsResolver = executedMigrationsResolver;
-    this.schemaMigrator = schemaMigrator;
-  }
-  async buildSchema(db, after) {
-    const newMigrations = await this.executedMigrationsResolver.getMigrations(db, after?.version);
-    if (newMigrations.length === 0) {
-      return after ?? emptyVersionedSchema;
-    }
-    const schema = newMigrations.reduce(
-      (schema2, migration) => {
-        if (migration.type !== "schema") {
-          return schema2;
-        }
-        return {
-          ...this.schemaMigrator.applyModifications(schema2, migration.modifications, migration.formatVersion),
-          version: migration.version,
-          id: migration.id
-        };
-      },
-      after?.notNormalized ?? emptyVersionedSchema.notNormalized
-    );
-    const normalized = schemaUtils.normalizeSchema(schema);
-    return {
-      ...normalized,
-      notNormalized: schema
-    };
-  }
-}
-exports.SchemaVersionBuilder = SchemaVersionBuilder;
-exports.emptyVersionedSchema = emptyVersionedSchema;
-//# sourceMappingURL=SchemaVersionBuilder.cjs.map

package/dist/development/src/model/migrations/SchemaVersionBuilder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaVersionBuilder.cjs","sources":["../../../../../../packages/engine-system-api/src/model/migrations/SchemaVersionBuilder.ts"],"sourcesContent":["import { Schema } from '@contember/schema'\nimport { SchemaMigrator } from '@contember/schema-migrations'\nimport { emptySchema } from '@contember/schema-utils'\nimport { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'\nimport { DatabaseContext } from '../database'\nimport { normalizeSchema } from '@contember/schema-utils'\n\nexport type VersionedSchema = Schema & { version: string; id: number; notNormalized: Schema & { version: string; id: number } }\n\nexport const emptyVersionedSchema = { ...normalizeSchema(emptySchema), version: '', id: -1, notNormalized: { ...emptySchema, version: '', id: -1 } }\n\nexport class SchemaVersionBuilder {\n\tconstructor(\n\t\tprivate readonly executedMigrationsResolver: ExecutedMigrationsResolver,\n\t\tprivate readonly schemaMigrator: SchemaMigrator,\n\t) {}\n\n\tasync buildSchema(db: DatabaseContext, after?: VersionedSchema): Promise<VersionedSchema> {\n\t\tconst newMigrations = (await this.executedMigrationsResolver.getMigrations(db, after?.version))\n\t\tif (newMigrations.length === 0) {\n\t\t\treturn after ?? emptyVersionedSchema\n\t\t}\n\n\t\tconst schema = newMigrations.reduce(\n\t\t\t(schema, migration) => {\n\t\t\t\tif (migration.type !== 'schema') {\n\t\t\t\t\treturn schema\n\t\t\t\t}\n\t\t\t\treturn ({\n\t\t\t\t\t...this.schemaMigrator.applyModifications(schema, migration.modifications, migration.formatVersion),\n\t\t\t\t\tversion: migration.version,\n\t\t\t\t\tid: migration.id,\n\t\t\t\t})\n\t\t\t},\n\t\t\tafter?.notNormalized ?? emptyVersionedSchema.notNormalized,\n\t\t)\n\t\tconst normalized = normalizeSchema(schema)\n\t\treturn {\n\t\t\t...normalized,\n\t\t\tnotNormalized: schema,\n\t\t}\n\t}\n}\n"],"names":["normalizeSchema","emptySchema","schema"],"mappings":";;;AASO,MAAM,uBAAuB,EAAE,GAAGA,4BAAgBC,YAAAA,WAAW,GAAG,SAAS,IAAI,IAAI,IAAI,eAAe,EAAE,GAAGA,yBAAa,SAAS,IAAI,IAAI,KAAK;AAE5I,MAAM,qBAAqB;AAAA,EACjC,YACkB,4BACA,gBAChB;AAFgB,SAAA,6BAAA;AACA,SAAA,iBAAA;AAAA,EACf;AAAA,EAEH,MAAM,YAAY,IAAqB,OAAmD;AACzF,UAAM,gBAAiB,MAAM,KAAK,2BAA2B,cAAc,IAAI,OAAO,OAAO;AACzF,QAAA,cAAc,WAAW,GAAG;AAC/B,aAAO,SAAS;AAAA,IACjB;AAEA,UAAM,SAAS,cAAc;AAAA,MAC5B,CAACC,SAAQ,cAAc;AAClB,YAAA,UAAU,SAAS,UAAU;AACzBA,iBAAAA;AAAAA,QACR;AACQ,eAAA;AAAA,UACP,GAAG,KAAK,eAAe,mBAAmBA,SAAQ,UAAU,eAAe,UAAU,aAAa;AAAA,UAClG,SAAS,UAAU;AAAA,UACnB,IAAI,UAAU;AAAA,QAAA;AAAA,MAEhB;AAAA,MACA,OAAO,iBAAiB,qBAAqB;AAAA,IAAA;AAExC,UAAA,aAAaF,4BAAgB,MAAM;AAClC,WAAA;AAAA,MACN,GAAG;AAAA,MACH,eAAe;AAAA,IAAA;AAAA,EAEjB;AACD;;;"}