@contember/engine-system-api 2.1.0-beta.2 → 2.2.0-alpha.2

package/src/schema/types.ts

@@ -1,11 +1,8 @@
+/** Internal type. DO NOT USE DIRECTLY. */
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
 import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'
 export type Maybe<T> = T | null
 export type InputMaybe<T> = Maybe<T>
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
-export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never }
-export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }
 export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
@@ -17,7 +14,7 @@ export type Scalars = {
 	DateTime: { input: Date; output: Date }
 	Json: { input: unknown; output: unknown }
 	PrimaryKey: { input: string | number; output: string | number }
-	Schema: { input: any; output: any }
+	Schema: { input: unknown; output: unknown }
 }
 
 export type ContentMigration = {
@@ -64,8 +61,8 @@ export type Event = {
 	readonly id: Scalars['String']['output']
 	readonly identityDescription: Scalars['String']['output']
 	readonly identityId: Scalars['String']['output']
-	readonly primaryKey: ReadonlyArray<Scalars['PrimaryKey']['output']>
-	readonly tableName: Scalars['String']['output']
+	readonly primaryKey?: Maybe<ReadonlyArray<Scalars['PrimaryKey']['output']>>
+	readonly tableName?: Maybe<Scalars['String']['output']>
 	readonly transactionId: Scalars['String']['output']
 	readonly type: EventType
 }
@@ -78,6 +75,7 @@ export type EventFilterRow = {
 export enum EventType {
 	Create = 'CREATE',
 	Delete = 'DELETE',
+	Truncate = 'TRUNCATE',
 	Update = 'UPDATE',
 }
 
@@ -137,6 +135,7 @@ export enum MigrateErrorCode {
 	InvalidSchema = 'INVALID_SCHEMA',
 	MigrationFailed = 'MIGRATION_FAILED',
 	MustFollowLatest = 'MUST_FOLLOW_LATEST',
+	ProjectNotEmpty = 'PROJECT_NOT_EMPTY',
 }
 
 export type MigrateResponse = {
@@ -221,6 +220,12 @@ export type Mutation = {
 	readonly __typename?: 'Mutation'
 	readonly forceMigrate: MigrateResponse
 	readonly migrate: MigrateResponse
+	/**
+	 * Bootstraps an empty project from a snapshot: applies the collapsed schema in a
+	 * single step and records the covered migrations as executed without replaying them.
+	 * Refused (PROJECT_NOT_EMPTY) when any migration has already been executed.
+	 */
+	readonly migrateFromSnapshot: MigrateResponse
 	readonly migrationDelete: MigrationDeleteResponse
 	readonly migrationModify: MigrationModifyResponse
 	readonly truncate: TruncateResponse
@@ -228,10 +233,17 @@ export type Mutation = {
 
 export type MutationForceMigrateArgs = {
 	migrations: ReadonlyArray<Migration>
+	schemaState?: InputMaybe<SchemaStateInput>
 }
 
 export type MutationMigrateArgs = {
 	migrations: ReadonlyArray<Migration>
+	schemaState?: InputMaybe<SchemaStateInput>
+}
+
+export type MutationMigrateFromSnapshotArgs = {
+	schemaState?: InputMaybe<SchemaStateInput>
+	snapshot: SnapshotInput
 }
 
 export type MutationMigrationDeleteArgs = {
@@ -265,6 +277,21 @@ export type SchemaMigration = {
 	readonly skippedErrors?: InputMaybe<ReadonlyArray<MigrationSkippedError>>
 }
 
+export type SchemaStateInput = {
+	readonly acl: Scalars['Json']['input']
+	readonly actions: Scalars['Json']['input']
+	readonly settings: Scalars['Json']['input']
+	readonly validation: Scalars['Json']['input']
+}
+
+export type SnapshotInput = {
+	/** Migrations subsumed by the snapshot, recorded as executed without running their SQL. */
+	readonly covers: ReadonlyArray<Migration>
+	/** Collapsed schema (empty -> target) applied once to every stage. */
+	readonly formatVersion: Scalars['Int']['input']
+	readonly modifications: ReadonlyArray<Scalars['Json']['input']>
+}
+
 export type Stage = {
 	readonly __typename?: 'Stage'
 	readonly id: Scalars['String']['output']
@@ -272,6 +299,20 @@ export type Stage = {
 	readonly slug: Scalars['String']['output']
 }
 
+export type TruncateEvent = Event & {
+	readonly __typename?: 'TruncateEvent'
+	readonly appliedAt: Scalars['DateTime']['output']
+	readonly createdAt: Scalars['DateTime']['output']
+	readonly description: Scalars['String']['output']
+	readonly id: Scalars['String']['output']
+	readonly identityDescription: Scalars['String']['output']
+	readonly identityId: Scalars['String']['output']
+	readonly primaryKey?: Maybe<ReadonlyArray<Scalars['PrimaryKey']['output']>>
+	readonly tableName?: Maybe<Scalars['String']['output']>
+	readonly transactionId: Scalars['String']['output']
+	readonly type: EventType
+}
+
 export type TruncateResponse = {
 	readonly __typename?: 'TruncateResponse'
 	readonly ok: Scalars['Boolean']['output']
@@ -298,7 +339,7 @@ export type ResolverTypeWrapper<T> = Promise<T> | T
 export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
 	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
 }
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
+export type Resolver<TResult, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> =
 	| ResolverFn<TResult, TParent, TContext, TArgs>
 	| ResolverWithResolve<TResult, TParent, TContext, TArgs>
 
@@ -337,21 +378,36 @@ export type SubscriptionObject<TResult, TKey extends string, TParent, TContext,
 	| SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
 	| SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
 
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
+export type SubscriptionResolver<
+	TResult,
+	TKey extends string,
+	TParent = Record<PropertyKey, never>,
+	TContext = Record<PropertyKey, never>,
+	TArgs = Record<PropertyKey, never>,
+> =
 	| ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
 	| SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
 
-export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+export type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (
 	parent: TParent,
 	context: TContext,
 	info: GraphQLResolveInfo,
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>
 
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
+export type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (
+	obj: T,
+	context: TContext,
+	info: GraphQLResolveInfo,
+) => boolean | Promise<boolean>
 
 export type NextResolverFn<T> = () => Promise<T>
 
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+export type DirectiveResolverFn<
+	TResult = Record<PropertyKey, never>,
+	TParent = Record<PropertyKey, never>,
+	TContext = Record<PropertyKey, never>,
+	TArgs = Record<PropertyKey, never>,
+> = (
 	next: NextResolverFn<TResult>,
 	parent: TParent,
 	args: TArgs,
@@ -361,7 +417,11 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 
 /** Mapping of interface types */
 export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
-	Event: (CreateEvent) | (DeleteEvent) | (UpdateEvent)
+	Event:
+		| (CreateEvent)
+		| (DeleteEvent)
+		| (TruncateEvent)
+		| (UpdateEvent)
 }
 
 /** Mapping between all available schema types and the resolvers types */
@@ -395,13 +455,16 @@ export type ResolversTypes = {
 	MigrationModifyResponse: ResolverTypeWrapper<MigrationModifyResponse>
 	MigrationSkippedError: MigrationSkippedError
 	MigrationType: MigrationType
-	Mutation: ResolverTypeWrapper<{}>
+	Mutation: ResolverTypeWrapper<Record<PropertyKey, never>>
 	PrimaryKey: ResolverTypeWrapper<Scalars['PrimaryKey']['output']>
-	Query: ResolverTypeWrapper<{}>
+	Query: ResolverTypeWrapper<Record<PropertyKey, never>>
 	Schema: ResolverTypeWrapper<Scalars['Schema']['output']>
 	SchemaMigration: SchemaMigration
+	SchemaStateInput: SchemaStateInput
+	SnapshotInput: SnapshotInput
 	Stage: ResolverTypeWrapper<Stage>
 	String: ResolverTypeWrapper<Scalars['String']['output']>
+	TruncateEvent: ResolverTypeWrapper<TruncateEvent>
 	TruncateResponse: ResolverTypeWrapper<TruncateResponse>
 	UpdateEvent: ResolverTypeWrapper<UpdateEvent>
 }
@@ -431,13 +494,16 @@ export type ResolversParentTypes = {
 	MigrationModifyError: MigrationModifyError
 	MigrationModifyResponse: MigrationModifyResponse
 	MigrationSkippedError: MigrationSkippedError
-	Mutation: {}
+	Mutation: Record<PropertyKey, never>
 	PrimaryKey: Scalars['PrimaryKey']['output']
-	Query: {}
+	Query: Record<PropertyKey, never>
 	Schema: Scalars['Schema']['output']
 	SchemaMigration: SchemaMigration
+	SchemaStateInput: SchemaStateInput
+	SnapshotInput: SnapshotInput
 	Stage: Stage
 	String: Scalars['String']['output']
+	TruncateEvent: TruncateEvent
 	TruncateResponse: TruncateResponse
 	UpdateEvent: UpdateEvent
 }
@@ -477,17 +543,7 @@ export type DeleteEventResolvers<ContextType = any, ParentType extends Resolvers
 }
 
 export type EventResolvers<ContextType = any, ParentType extends ResolversParentTypes['Event'] = ResolversParentTypes['Event']> = {
-	__resolveType: TypeResolveFn<'CreateEvent' | 'DeleteEvent' | 'UpdateEvent', ParentType, ContextType>
-	appliedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
-	createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
-	description?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	id?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	identityDescription?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	identityId?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	primaryKey?: Resolver<ReadonlyArray<ResolversTypes['PrimaryKey']>, ParentType, ContextType>
-	tableName?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	transactionId?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['EventType'], ParentType, ContextType>
+	__resolveType: TypeResolveFn<'CreateEvent' | 'DeleteEvent' | 'TruncateEvent' | 'UpdateEvent', ParentType, ContextType>
 }
 
 export type ExecutedMigrationResolvers<
@@ -500,7 +556,6 @@ export type ExecutedMigrationResolvers<
 	modifications?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Json']>>, ParentType, ContextType>
 	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	version?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
@@ -512,7 +567,6 @@ export type MigrateErrorResolvers<ContextType = any, ParentType extends Resolver
 		code?: Resolver<ResolversTypes['MigrateErrorCode'], ParentType, ContextType>
 		developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 		migration?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-		__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 	}
 
 export type MigrateResponseResolvers<
@@ -523,7 +577,6 @@ export type MigrateResponseResolvers<
 	errors?: Resolver<ReadonlyArray<ResolversTypes['MigrateError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	result?: Resolver<Maybe<ResolversTypes['MigrateResult']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MigrateResultResolvers<
@@ -531,7 +584,6 @@ export type MigrateResultResolvers<
 	ParentType extends ResolversParentTypes['MigrateResult'] = ResolversParentTypes['MigrateResult'],
 > = {
 	message?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MigrationDeleteErrorResolvers<
@@ -540,7 +592,6 @@ export type MigrationDeleteErrorResolvers<
 > = {
 	code?: Resolver<ResolversTypes['MigrationDeleteErrorCode'], ParentType, ContextType>
 	developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MigrationDeleteResponseResolvers<
@@ -549,7 +600,6 @@ export type MigrationDeleteResponseResolvers<
 > = {
 	error?: Resolver<Maybe<ResolversTypes['MigrationDeleteError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MigrationModifyErrorResolvers<
@@ -558,7 +608,6 @@ export type MigrationModifyErrorResolvers<
 > = {
 	code?: Resolver<ResolversTypes['MigrationModifyErrorCode'], ParentType, ContextType>
 	developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MigrationModifyResponseResolvers<
@@ -567,12 +616,17 @@ export type MigrationModifyResponseResolvers<
 > = {
 	error?: Resolver<Maybe<ResolversTypes['MigrationModifyError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
 	forceMigrate?: Resolver<ResolversTypes['MigrateResponse'], ParentType, ContextType, RequireFields<MutationForceMigrateArgs, 'migrations'>>
 	migrate?: Resolver<ResolversTypes['MigrateResponse'], ParentType, ContextType, RequireFields<MutationMigrateArgs, 'migrations'>>
+	migrateFromSnapshot?: Resolver<
+		ResolversTypes['MigrateResponse'],
+		ParentType,
+		ContextType,
+		RequireFields<MutationMigrateFromSnapshotArgs, 'snapshot'>
+	>
 	migrationDelete?: Resolver<
 		ResolversTypes['MigrationDeleteResponse'],
 		ParentType,
@@ -607,6 +661,22 @@ export type StageResolvers<ContextType = any, ParentType extends ResolversParent
 	id?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	slug?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+}
+
+export type TruncateEventResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['TruncateEvent'] = ResolversParentTypes['TruncateEvent'],
+> = {
+	appliedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
+	createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
+	description?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	id?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	identityDescription?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	identityId?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	primaryKey?: Resolver<Maybe<ReadonlyArray<ResolversTypes['PrimaryKey']>>, ParentType, ContextType>
+	tableName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
+	transactionId?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	type?: Resolver<ResolversTypes['EventType'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
@@ -615,7 +685,6 @@ export type TruncateResponseResolvers<
 	ParentType extends ResolversParentTypes['TruncateResponse'] = ResolversParentTypes['TruncateResponse'],
 > = {
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type UpdateEventResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateEvent'] = ResolversParentTypes['UpdateEvent']> = {
@@ -653,6 +722,7 @@ export type Resolvers<ContextType = any> = {
 	Query?: QueryResolvers<ContextType>
 	Schema?: GraphQLScalarType
 	Stage?: StageResolvers<ContextType>
+	TruncateEvent?: TruncateEventResolvers<ContextType>
 	TruncateResponse?: TruncateResponseResolvers<ContextType>
 	UpdateEvent?: UpdateEventResolvers<ContextType>
 }

package/src/utils/batchQuery.ts

@@ -1,4 +1,4 @@
-import { waitForTick } from './tick'
+import { waitForTick } from './tick.js'
 
 export type ItemLoader<Arg, Item> = (args: Arg) => Promise<Item>
 

package/src/utils/index.ts

@@ -1,7 +1,7 @@
-export * from './assertNever'
-export * from './exceptions'
-export * from './providers'
-export * from './uuid'
-export * from './MapSet'
-export * from './Response'
-export * from './tuple'
+export * from './assertNever.js'
+export * from './exceptions.js'
+export * from './providers.js'
+export * from './uuid.js'
+export * from './MapSet.js'
+export * from './Response.js'
+export * from './tuple.js'

package/src/utils/providers.ts

@@ -1,3 +1,3 @@
-import { UuidProvider } from './uuid'
+import { UuidProvider } from './uuid.js'
 
 export type Providers = UuidProvider

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

@@ -1,5 +1,5 @@
 import { emptyDatabaseMetadata } from '@contember/database'
-import migration from '../../../src/migrations/2020-05-06-150000-composed-primary'
+import migration from '../../../src/migrations/2020-05-06-150000-composed-primary.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { c, createSchema } from '@contember/schema-definition'

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

@@ -1,4 +1,4 @@
-import migration from '../../../src/migrations/2020-06-01-103000-event-trigger-perf'
+import migration from '../../../src/migrations/2020-06-01-103000-event-trigger-perf.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { emptyDatabaseMetadata } from '@contember/database'

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

@@ -1,4 +1,4 @@
-import migration from '../../../src/migrations/2022-10-03-110000-table-on-delete'
+import migration from '../../../src/migrations/2022-10-03-110000-table-on-delete.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { SchemaBuilder } from '@contember/schema-definition'

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

@@ -1,4 +1,4 @@
-import migration from '../../../src/migrations/2023-09-11-174000-fix-on-delete'
+import migration from '../../../src/migrations/2023-09-11-174000-fix-on-delete.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { SchemaBuilder } from '@contember/schema-definition'

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

@@ -1,4 +1,4 @@
-import migration from '../../../src/migrations/2023-10-19-173000-fix-unique'
+import migration from '../../../src/migrations/2023-10-19-173000-fix-unique.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { c, createSchema } from '@contember/schema-definition'

package/tests/cases/migrations/2025-03-14-110000-fix-missing-index.test.ts

@@ -1,4 +1,4 @@
-import migration from '../../../src/migrations/2025-03-14-110000-fix-missing-index'
+import migration from '../../../src/migrations/2025-03-14-110000-fix-missing-index.js'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { expect, test } from 'bun:test'
 import { c, createSchema } from '@contember/schema-definition'

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

@@ -1,7 +1,7 @@
 import { expect, test } from 'bun:test'
-import { EventsQuery } from '../../../src/model'
-import { testUuid } from '../../src/uuid'
-import { EventsOrder } from '../../../src/schema'
+import { EventsQuery } from '../../../src/model/index.js'
+import { testUuid } from '../../src/uuid.js'
+import { EventsOrder } from '../../../src/schema/index.js'
 
 test('events query', async () => {
 	const query = new EventsQuery(

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

@@ -0,0 +1,48 @@
+import { expect, test } from 'bun:test'
+import { InvalidSchemaError, MigrationError, ProjectMigrator } from '../../../src/model/index.js'
+import { SchemaStateInput } from '../../../src/model/migrations/MigrationInput.js'
+import { emptySchema } from '@contember/schema-utils'
+
+// The state-only path never touches the database (no migrations to apply, no schema row to save on a
+// fresh project), so the collaborators that would hit the DB can be stubbed.
+const buildMigrator = () =>
+	new ProjectMigrator(
+		{} as any, // migrationDescriber — unused without schema migrations
+		{ fetch: async () => ({ schema: emptySchema, meta: {} }) } as any, // SchemaProvider: fresh project, no schema row
+		{ getMigrations: async () => [] } as any, // ExecutedMigrationsResolver: nothing executed
+		{ create: () => ({ getMetadata: async () => ({}), invalidate: () => {} }) } as any,
+		{} as any, // contentQueryExecutor — unused
+	)
+
+const migrate = (schemaState: SchemaStateInput) =>
+	buildMigrator().migrate({
+		db: {} as any,
+		project: { slug: 'test', systemSchema: 'system' },
+		identity: { id: '00000000-0000-0000-0000-000000000000' },
+		stages: [],
+		migrationsToExecute: [],
+		schemaState,
+		options: {},
+	})
+
+const stateWith = (acl: unknown): SchemaStateInput => ({
+	acl,
+	validation: emptySchema.validation,
+	actions: emptySchema.actions,
+	settings: emptySchema.settings,
+})
+
+test('state-only migrate on a fresh project (no migrations) is a clean no-op, not a crash', async () => {
+	// Regression: previously the `!id` guard threw ImplementationException before the intended
+	// fresh-project early return — and ImplementationException is not a MigrationError, so it leaked.
+	const validAcl = { roles: { admin: { variables: {}, stages: '*', entities: {} } } }
+	await expect(migrate(stateWith(validAcl))).resolves.toBeUndefined()
+})
+
+test('invalid overlaid schema state is rejected as a MigrationError (clean INVALID_SCHEMA)', async () => {
+	// acl referencing an entity that does not exist in the model
+	const invalidAcl = { roles: { admin: { variables: {}, stages: '*', entities: { Unknown: { predicates: {}, operations: {} } } } } }
+	const err = await migrate(stateWith(invalidAcl)).then(() => null, e => e)
+	expect(err).toBeInstanceOf(InvalidSchemaError)
+	expect(err).toBeInstanceOf(MigrationError)
+})

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

@@ -0,0 +1,54 @@
+import { expect, test } from 'bun:test'
+import { TruncateEventsCommand } from '../../../src/model/index.js'
+import { testUuid } from '../../src/uuid.js'
+
+const createMockDb = () => {
+	const queries: { sql: string; params: any[] }[] = []
+	return {
+		queries,
+		db: {
+			schema: 'public',
+			query: async (sql: string, params: any[] = []) => {
+				queries.push({ sql, params })
+				return { rows: [], rowCount: 0 }
+			},
+		} as any,
+	}
+}
+
+test('truncate events command clears the event log and records a truncate event', async () => {
+	const { db, queries } = createMockDb()
+	let uuidCounter = 100
+	const providers = { uuid: () => testUuid(uuidCounter++) }
+
+	const command = new TruncateEventsCommand(testUuid(1), [testUuid(2), testUuid(3)])
+	await command.execute({ db, providers, bus: {} as any })
+
+	// 1x delete + 1x insert into event_data + 2x insert into stage_transaction
+	expect(queries.length).toBe(4)
+
+	const [del, insertEvent, stage1, stage2] = queries
+
+	expect(del.sql).toContain('delete from')
+	expect(del.sql).toContain('"event_data"')
+
+	expect(insertEvent.sql).toContain('insert into')
+	expect(insertEvent.sql).toContain('"event_data"')
+	expect(insertEvent.sql).toContain('clock_timestamp()')
+	expect(insertEvent.sql).toContain('MAX("id")')
+	expect(insertEvent.sql).toContain('"schema_migration"')
+	// type 'truncate' and identity id are passed as bound params
+	expect(insertEvent.params).toContain('truncate')
+	expect(insertEvent.params).toContain(testUuid(1))
+
+	for (const stageInsert of [stage1, stage2]) {
+		expect(stageInsert.sql).toContain('insert into')
+		expect(stageInsert.sql).toContain('"stage_transaction"')
+		expect(stageInsert.sql).toContain('on conflict')
+		expect(stageInsert.sql).toContain('do nothing')
+	}
+	// both stages linked to the same (single) truncate transaction
+	const stageIds = [...stage1.params, ...stage2.params]
+	expect(stageIds).toContain(testUuid(2))
+	expect(stageIds).toContain(testUuid(3))
+})