@verdant-web/store 4.6.0 → 5.0.0

package/src/persistence/idb/metadata/IdbMetadataDb.ts

@@ -8,7 +8,7 @@ import {
 	getOidSubIdRange,
 	ObjectIdentifier,
 } from '@verdant-web/common';
-import { InitialContext } from '../../../context/context.js';
+import { ContextWithoutPersistence } from '../../../context/context.js';
 import {
 	AbstractTransaction,
 	AckInfo,
@@ -37,10 +37,10 @@ export class IdbMetadataDb
 	extends IdbService
 	implements PersistenceMetadataDb<IDBTransaction>
 {
-	constructor(db: IDBDatabase, ctx: InitialContext) {
+	constructor(db: IDBDatabase, ctx: ContextWithoutPersistence) {
 		super(db, ctx);
 		this.addDispose(() => {
-			this.ctx.log('info', `Closing metadata DB for`, this.ctx.namespace);
+			this.ctx.log('info', `Closing metadata DB for`, ctx.namespace);
 			return closeDatabase(db);
 		});
 	}

package/src/persistence/idb/queries/IdbDocumentDb.ts

@@ -5,7 +5,7 @@ import {
 	getIndexValues,
 	ObjectIdentifier,
 } from '@verdant-web/common';
-import { InitialContext } from '../../../context/context.js';
+import { ContextWithoutPersistence } from '../../../context/context.js';
 import { PersistenceDocumentDb } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
 import {
@@ -17,10 +17,17 @@ import {
 import { getRange } from './ranges.js';
 
 export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
-	constructor(db: IDBDatabase, context: InitialContext) {
+	constructor(
+		db: IDBDatabase,
+		private context: ContextWithoutPersistence,
+	) {
 		super(db, context);
 		this.addDispose(() => {
-			this.ctx.log('info', 'Closing document database for', this.ctx.namespace);
+			this.context.log(
+				'info',
+				'Closing document database for',
+				context.namespace,
+			);
 			return closeDatabase(this.db);
 		});
 	}
@@ -32,7 +39,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 	stats = async (): Promise<
 		Record<string, { count: number; size: number }>
 	> => {
-		const collectionNames = Object.keys(this.ctx.schema.collections);
+		const collectionNames = Object.keys(this.context.schema.collections);
 		const collections: Record<string, { count: number; size: number }> = {};
 		await Promise.all(
 			collectionNames.map(async (name) => {
@@ -54,7 +61,11 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 					? store.index(opts.index.where)
 					: store;
 				const direction = opts.index?.order === 'desc' ? 'prev' : 'next';
-				const range = getRange(this.ctx.schema, opts.collection, opts.index);
+				const range = getRange(
+					this.context.schema,
+					opts.collection,
+					opts.index,
+				);
 				return source.openCursor(range, direction);
 			},
 			{ mode: 'readonly' },
@@ -82,7 +93,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 		const store = tx.objectStore(collection);
 		const source = index?.where ? store.index(index.where) : store;
 		const direction = index?.order === 'desc' ? 'prev' : 'next';
-		const range = getRange(this.ctx.schema, collection, index);
+		const range = getRange(this.context.schema, collection, index);
 		const request = source.openCursor(range, direction);
 
 		let hasNextPage = false;
@@ -124,7 +135,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 
 			request.onerror = () => {
 				if (request.error?.name === 'InvalidStateError') {
-					this.ctx.log(
+					this.context.log(
 						'error',
 						`find query failed with InvalidStateError`,
 						request.error,
@@ -161,7 +172,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 				try {
 					await this.saveDocument(e.oid, snapshot, options);
 				} catch (err) {
-					this.ctx.log(
+					this.context.log(
 						'error',
 						`Error saving document ${e.oid} (${JSON.stringify(snapshot)})`,
 						err,
@@ -186,7 +197,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 					'Failed to save any documents. Something must be quite wrong.',
 				);
 			}
-			this.ctx.log(
+			this.context.log(
 				'error',
 				'Failed to save documents:',
 				failures,
@@ -198,15 +209,15 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 	};
 
 	reset = async (): Promise<void> => {
-		const names = Object.keys(this.ctx.schema.collections);
+		const names = Object.keys(this.context.schema.collections);
 		const tx = this.createTransaction(names, { mode: 'readwrite' });
 		await Promise.all(
 			names.map((name) =>
 				this.run(name, (store) => store.clear(), { transaction: tx }),
 			),
 		);
-		this.ctx.entityEvents.emit('collectionsChanged', names);
-		this.ctx.log('info', '💨 Reset queryable storage');
+		this.context.entityEvents.emit('collectionsChanged', names);
+		this.context.log('info', '💨 Reset queryable storage');
 	};
 
 	private saveDocument = async (
@@ -214,7 +225,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 		doc: any,
 		{ transaction }: { transaction?: IDBTransaction },
 	) => {
-		this.ctx.log('debug', `Saving document indexes for querying ${oid}`);
+		this.context.log('debug', `Saving document indexes for querying ${oid}`);
 		const { collection, id } = decomposeOid(oid);
 		try {
 			if (!doc) {
@@ -222,9 +233,12 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 					mode: 'readwrite',
 					transaction,
 				});
-				this.ctx.log('debug', `Deleted document indexes for querying ${oid}`);
+				this.context.log(
+					'debug',
+					`Deleted document indexes for querying ${oid}`,
+				);
 			} else {
-				const schema = this.ctx.schema.collections[collection];
+				const schema = this.context.schema.collections[collection];
 				// no need to validate before storing; the entity's snapshot is already validated.
 				const indexes = getIndexValues(schema, doc);
 				indexes['@@@snapshot'] = JSON.stringify(doc);
@@ -232,10 +246,10 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 					mode: 'readwrite',
 					transaction,
 				});
-				this.ctx.log('debug', `Save complete for ${oid}`, indexes);
+				this.context.log('debug', `Save complete for ${oid}`, indexes);
 			}
 		} catch (err) {
-			this.ctx.log('error', `Error saving document ${oid}`, err);
+			this.context.log('error', `Error saving document ${oid}`, err);
 			throw err;
 		}
 	};

package/src/persistence/idb/queries/migration/db.ts

@@ -67,12 +67,22 @@ export async function openDatabase({
 	version: number;
 	log?: Context['log'];
 }): Promise<IDBDatabase> {
+	if (version <= 0) {
+		throw new Error('Cannot open database at version less than 1');
+	}
 	log?.('debug', 'Opening database', namespace, 'at version', version);
 	const db = await baseOpenDatabase(
 		getDocumentDbName(namespace),
 		version,
 		indexedDB,
 	);
+	log?.('debug', 'Database opened', namespace, 'at version', db.version);
+	if (db.version !== version) {
+		log?.(
+			'warn',
+			`Opened database version ${db.version} but expected version ${version} for namespace ${namespace}`,
+		);
+	}
 
 	db.addEventListener('versionchange', (event) => {
 		db.close();

package/src/persistence/idb/util.ts

@@ -267,7 +267,15 @@ export async function overwriteDatabase(
 	}
 
 	const to = await new Promise<IDBDatabase>((resolve, reject) => {
-		ctx.log('debug', 'Opening reset database', toName, 'at', from.version);
+		ctx.log(
+			'debug',
+			'Copying to database',
+			toName,
+			'at',
+			from.version,
+			'from',
+			from.name,
+		);
 		const openRequest = indexedDB.open(toName, from.version);
 		openRequest.onupgradeneeded = () => {
 			ctx.log(
@@ -284,6 +292,7 @@ export async function overwriteDatabase(
 				throw new Error('No transaction');
 			}
 			for (const storeName of Array.from(original.objectStoreNames)) {
+				ctx.log('debug', 'Copying object store', storeName);
 				const originalObjectStore = original
 					.transaction(storeName)
 					.objectStore(storeName);
@@ -314,31 +323,35 @@ export async function overwriteDatabase(
 			reject(openRequest.error ?? new Error('Unknown database upgrade error'));
 	});
 
-	const records = await getAllFromObjectStores(
-		from,
-		Array.from(from.objectStoreNames),
-	);
-	await new Promise<void>((resolve, reject) => {
-		const writeTx = to.transaction(
-			Array.from(to.objectStoreNames),
-			'readwrite',
+	// only copy data to new database if there are object stores to
+	// copy to
+	if (to.objectStoreNames.length > 0) {
+		const records = await getAllFromObjectStores(
+			from,
+			Array.from(from.objectStoreNames),
 		);
-		for (let i = 0; i < records.length; i++) {
-			const store = writeTx.objectStore(from.objectStoreNames[i]);
-			for (const record of records[i]) {
-				store.add(record);
+		await new Promise<void>((resolve, reject) => {
+			const writeTx = to.transaction(
+				Array.from(to.objectStoreNames),
+				'readwrite',
+			);
+			for (let i = 0; i < records.length; i++) {
+				const store = writeTx.objectStore(from.objectStoreNames[i]);
+				for (const record of records[i]) {
+					store.add(record);
+				}
 			}
-		}
-		writeTx.oncomplete = () => resolve();
-		writeTx.onerror = (ev) => {
-			const err =
-				writeTx.error ??
-				(ev.target as any).transaction?.error ??
-				new Error('Unknown error');
-			ctx.log('critical', 'Error copying data', err);
-			reject(err);
-		};
-	});
+			writeTx.oncomplete = () => resolve();
+			writeTx.onerror = (ev) => {
+				const err =
+					writeTx.error ??
+					(ev.target as any).transaction?.error ??
+					new Error('Unknown error');
+				ctx.log('critical', 'Error copying data', err);
+				reject(err);
+			};
+		});
+	}
 
 	await closeDatabase(to);
 }
@@ -351,6 +364,15 @@ export function openDatabase(
 	return new Promise<IDBDatabase>((resolve, reject) => {
 		const req = indexedDB.open(name, expectedVersion);
 		req.onsuccess = () => {
+			if (req.result.version !== expectedVersion) {
+				req.result.close();
+				reject(
+					new Error(
+						`Migration error: opened database version ${req.result.version} but expected version ${expectedVersion} for database ${name}`,
+					),
+				);
+				return;
+			}
 			resolve(req.result);
 		};
 		req.onerror = () => {

package/src/persistence/interfaces.ts

@@ -6,7 +6,7 @@ import {
 	ObjectIdentifier,
 	Operation,
 } from '@verdant-web/common';
-import { Context, InitialContext } from '../context/context.js';
+import { Context, ContextWithoutPersistence } from '../context/context.js';
 
 export interface AckInfo {
 	globalAckTimestamp: string | null;
@@ -187,21 +187,22 @@ export interface PersistenceFileDb {
 	iterateOverPendingDelete(
 		iterator: (file: PersistedFileData) => void,
 	): Promise<void>;
-	loadFileContents(file: FileData, ctx: Context): Promise<Blob>;
+	loadFileContents(
+		file: FileData,
+		ctx: Omit<Context, 'queries'>,
+	): Promise<Blob>;
 	getAll(): Promise<PersistedFileData[]>;
 	stats(): Promise<{ size: { count: number; size: number } }>;
 }
 
 export interface PersistenceNamespace {
-	openMetadata(ctx: InitialContext): Promise<PersistenceMetadataDb>;
+	openMetadata(ctx: ContextWithoutPersistence): Promise<PersistenceMetadataDb>;
 	/**
 	 * Open the Documents database according to the schema in the given
 	 * context. By the time this is called with a version, relevant migrations
 	 * will have been applied.
 	 */
-	openDocuments(
-		ctx: Omit<Context, 'documents' | 'files'>,
-	): Promise<PersistenceDocumentDb>;
+	openDocuments(ctx: ContextWithoutPersistence): Promise<PersistenceDocumentDb>;
 	/**
 	 * Apply a migration to the namespace provided in ctx.
 	 * This should make any transformations necessary to the
@@ -212,10 +213,11 @@ export interface PersistenceNamespace {
 	 * This method should also store the new version to persisted
 	 * metadata, however your implementation chooses to do that.
 	 */
-	applyMigration(ctx: InitialContext, migration: Migration<any>): Promise<void>;
-	openFiles(
-		ctx: Omit<Context, 'files' | 'documents'>,
-	): Promise<PersistenceFileDb>;
+	applyMigration(
+		ctx: ContextWithoutPersistence,
+		migration: Migration<any>,
+	): Promise<void>;
+	openFiles(ctx: ContextWithoutPersistence): Promise<PersistenceFileDb>;
 }
 
 export interface PersistenceImplementation {
@@ -227,7 +229,10 @@ export interface PersistenceImplementation {
 	/** Returns a list of all persisted namespaces visible to this app. */
 	getNamespaces(): Promise<string[]>;
 	/** Deletes all data from a particular namespace. */
-	deleteNamespace(namespace: string, ctx: InitialContext): Promise<void>;
+	deleteNamespace(
+		namespace: string,
+		ctx: ContextWithoutPersistence,
+	): Promise<void>;
 	/** Gets the schema version of the given namespace */
 	getNamespaceVersion(namespace: string): Promise<number>;
 	/**
@@ -235,5 +240,9 @@ export interface PersistenceImplementation {
 	 * overwrite the target namespace such that data and database
 	 * schema are identical.
 	 */
-	copyNamespace(from: string, to: string, ctx: InitialContext): Promise<void>;
+	copyNamespace(
+		from: string,
+		to: string,
+		ctx: ContextWithoutPersistence,
+	): Promise<void>;
 }

package/src/persistence/migration/engine.ts

@@ -13,17 +13,20 @@ import {
 	getOid,
 	removeOidPropertiesFromAllSubObjects,
 } from '@verdant-web/common';
+import { ContextWithoutPersistence } from '../../context/context.js';
 import { PersistenceDocumentDb, PersistenceNamespace } from '../interfaces.js';
-import { OpenDocumentDbContext } from './types.js';
+import { PersistenceMetadata } from '../PersistenceMetadata.js';
 
 function getMigrationMutations({
 	migration,
 	newOids,
 	ctx,
+	meta,
 }: {
 	migration: Migration<any>;
 	newOids: string[];
-	ctx: OpenDocumentDbContext;
+	ctx: ContextWithoutPersistence;
+	meta: PersistenceMetadata;
 }) {
 	return migration.allCollections.reduce((acc, collectionName) => {
 		acc[collectionName] = {
@@ -36,7 +39,7 @@ function getMigrationMutations({
 				newOids.push(oid);
 
 				await ctx.time.withMigrationTime(migration.version, () =>
-					ctx.meta.insertData({
+					meta.insertData({
 						operations: ctx.patchCreator.createInitialize(
 							doc,
 							oid,
@@ -50,7 +53,7 @@ function getMigrationMutations({
 			delete: async (id: string) => {
 				const rootOid = createOid(collectionName, id);
 				await ctx.time.withMigrationTime(migration.version, () =>
-					ctx.meta.deleteDocument(rootOid),
+					meta.deleteDocument(rootOid),
 				);
 			},
 		};
@@ -62,16 +65,18 @@ function getMigrationQueries({
 	migration,
 	context,
 	documents,
+	meta,
 }: {
 	migration: Migration<any>;
-	context: OpenDocumentDbContext;
+	context: ContextWithoutPersistence;
 	documents: PersistenceDocumentDb;
+	meta: PersistenceMetadata;
 }) {
 	return migration.oldCollections.reduce((acc, collectionName) => {
 		acc[collectionName] = {
 			get: async (id: string) => {
 				const oid = createOid(collectionName, id);
-				const doc = await context.meta.getDocumentSnapshot(oid, {
+				const doc = await meta.getDocumentSnapshot(oid, {
 					// only get the snapshot up to the previous version (newer operations may have synced)
 					to: context.time.nowWithVersion(migration.oldSchema.version),
 				});
@@ -83,7 +88,7 @@ function getMigrationQueries({
 					index: filter,
 				});
 				if (!oid) return null;
-				const doc = await context.meta.getDocumentSnapshot(oid, {
+				const doc = await meta.getDocumentSnapshot(oid, {
 					// only get the snapshot up to the previous version (newer operations may have synced)
 					to: context.time.nowWithVersion(migration.oldSchema.version),
 				});
@@ -95,8 +100,8 @@ function getMigrationQueries({
 					index: filter,
 				});
 				const docs = await Promise.all(
-					oids.map((oid) =>
-						context.meta.getDocumentSnapshot(oid, {
+					oids.map(async (oid) =>
+						meta.getDocumentSnapshot(oid, {
 							// only get the snapshot up to the previous version (newer operations may have synced)
 							to: context.time.nowWithVersion(migration.oldSchema.version),
 						}),
@@ -113,18 +118,23 @@ export async function getMigrationEngine({
 	migration,
 	context,
 	ns,
+	meta,
 }: {
 	log?: (...args: any[]) => void;
 	migration: Migration;
-	context: OpenDocumentDbContext;
+	context: ContextWithoutPersistence;
 	ns: PersistenceNamespace;
+	meta: PersistenceMetadata;
 }): Promise<MigrationEngine> {
-	const migrationContext = {
-		...context,
+	const migrationContext = context.cloneWithOptions({
 		schema: migration.oldSchema,
-	};
+	});
 	if (migration.oldSchema.version === 0) {
-		return getInitialMigrationEngine({ migration, context: migrationContext });
+		return getInitialMigrationEngine({
+			migration,
+			context: migrationContext,
+			meta,
+		});
 	}
 
 	const newOids = new Array<ObjectIdentifier>();
@@ -134,14 +144,16 @@ export async function getMigrationEngine({
 		migration,
 		context: migrationContext,
 		documents,
+		meta,
 	});
 	const mutations = getMigrationMutations({
 		migration,
 		newOids,
 		ctx: migrationContext,
+		meta,
 	});
 	const deleteCollection = async (collection: string) => {
-		await context.meta.deleteCollection(collection);
+		await meta.deleteCollection(collection);
 	};
 	const awaitables = new Array<Promise<any>>();
 	const engine: MigrationEngine = {
@@ -166,7 +178,7 @@ export async function getMigrationEngine({
 					// when the snapshots themselves are derived from the same data...)
 					// maybe don't use the findAll query, and instead go a level
 					// lower to retain access to lower level data here?
-					const authz = await context.meta.getDocumentAuthz(rootOid);
+					const authz = await meta.getDocumentAuthz(rootOid);
 					const original = cloneDeep(doc);
 					// @ts-ignore - excessive type resolution
 					const newValue = await strategy(doc);
@@ -196,7 +208,7 @@ export async function getMigrationEngine({
 							},
 						);
 						if (patches.length > 0) {
-							await context.meta.insertData({
+							await meta.insertData({
 								operations: patches,
 								isLocal: true,
 							});
@@ -218,9 +230,11 @@ export async function getMigrationEngine({
 function getInitialMigrationEngine({
 	migration,
 	context,
+	meta,
 }: {
-	context: OpenDocumentDbContext;
+	context: ContextWithoutPersistence;
 	migration: Migration;
+	meta: PersistenceMetadata;
 }): MigrationEngine {
 	const newOids = new Array<ObjectIdentifier>();
 
@@ -236,6 +250,7 @@ function getInitialMigrationEngine({
 		migration,
 		newOids,
 		ctx: context,
+		meta,
 	});
 	const engine: MigrationEngine = {
 		log: context.log,

package/src/persistence/migration/finalize.ts

@@ -4,17 +4,20 @@ import {
 	Migration,
 	MigrationEngine,
 } from '@verdant-web/common';
+import { ContextWithoutPersistence } from '../../context/context.js';
 import { ClientOperation, PersistenceDocumentDb } from '../interfaces.js';
-import { OpenDocumentDbContext } from './types.js';
+import { PersistenceMetadata } from '../PersistenceMetadata.js';
 
 export async function finalizeMigration({
 	ctx,
 	documents,
 	migration,
+	meta,
 	engine,
 }: {
-	ctx: OpenDocumentDbContext;
+	ctx: ContextWithoutPersistence;
 	documents: PersistenceDocumentDb;
+	meta: PersistenceMetadata;
 	migration: Migration<any>;
 	engine: MigrationEngine;
 }) {
@@ -37,6 +40,7 @@ export async function finalizeMigration({
 		currentVersion: migration.oldSchema.version,
 		newVersion: migration.newSchema.version,
 		ctx,
+		meta,
 	});
 
 	// once the schema is ready, we can write back the migrated documents
@@ -58,7 +62,7 @@ export async function finalizeMigration({
 		const snapshots = await Promise.all(
 			oids.map(async (oid) => {
 				try {
-					const snap = await ctx.meta.getDocumentSnapshot(oid);
+					const snap = await meta.getDocumentSnapshot(oid);
 					return [oid, snap];
 				} catch (e) {
 					// this seems to happen with baselines/ops which are not fully
@@ -103,16 +107,18 @@ async function getDocsWithUnappliedMigrations({
 	currentVersion,
 	newVersion: _,
 	ctx,
+	meta,
 }: {
 	currentVersion: number;
 	newVersion: number;
-	ctx: OpenDocumentDbContext;
+	ctx: ContextWithoutPersistence;
+	meta: PersistenceMetadata;
 }) {
 	// scan for all operations in metadata after the current version.
 	// this could be more efficient if also filtering below or equal newVersion but
 	// that seems so unlikely in practice...
 	const unappliedOperations: ClientOperation[] = [];
-	await ctx.meta.iterateAllOperations(
+	await meta.iterateAllOperations(
 		(op) => {
 			unappliedOperations.push(op);
 		},

package/src/persistence/migration/migrate.ts

@@ -1,16 +1,19 @@
 import { Migration } from '@verdant-web/common';
+import { ContextWithoutPersistence } from '../../context/context.js';
 import { ShutdownHandler } from '../../context/ShutdownHandler.js';
 import { PersistenceNamespace } from '../interfaces.js';
+import { PersistenceMetadata } from '../PersistenceMetadata.js';
 import { getMigrationEngine } from './engine.js';
 import { finalizeMigration } from './finalize.js';
 import { getMigrationPath } from './paths.js';
-import { OpenDocumentDbContext } from './types.js';
 
 export async function migrate({
 	context,
 	version,
+	meta,
 }: {
-	context: OpenDocumentDbContext;
+	context: ContextWithoutPersistence;
+	meta: PersistenceMetadata;
 	version: number;
 }) {
 	const ns = await context.persistence.openNamespace(
@@ -45,7 +48,7 @@ export async function migrate({
 				'Migrations to run:',
 				toRun.map((m) => m.version),
 			);
-			await runMigrations({ context, ns, toRun });
+			await runMigrations({ context, ns, toRun, meta });
 		}
 	});
 }
@@ -63,10 +66,12 @@ export async function runMigrations({
 	context,
 	toRun,
 	ns,
+	meta,
 }: {
-	context: OpenDocumentDbContext;
+	context: ContextWithoutPersistence;
 	toRun: Migration<any>[];
 	ns: PersistenceNamespace;
+	meta: PersistenceMetadata;
 }) {
 	// disable rebasing for the duration of migrations
 	context.pauseRebasing = true;
@@ -76,16 +81,16 @@ export async function runMigrations({
 			'info',
 			`🚀 Running migration v${migration.oldSchema.version} -> v${migration.newSchema.version}`,
 		);
-		const migrationContext = {
-			...context,
+		const migrationContext = context.cloneWithOptions({
 			schema: migration.oldSchema,
-			shutdownHandler: new ShutdownHandler(context.log),
-		};
+			persistenceShutdownHandler: new ShutdownHandler(context.log),
+		});
 		// this will only write to our metadata store via operations!
 		const engine = await getMigrationEngine({
 			migration,
 			context: migrationContext,
 			ns,
+			meta,
 		});
 		try {
 			context.log(
@@ -98,6 +103,7 @@ export async function runMigrations({
 				migration.newSchema.version,
 			);
 			await migration.migrate(engine);
+			context.log('debug', 'Awaiting remaining migration tasks');
 			// wait on any out-of-band async operations to complete
 			await Promise.all(engine.awaitables);
 		} catch (err) {
@@ -136,6 +142,7 @@ export async function runMigrations({
 			migration,
 			engine,
 			documents: upgradedDocuments,
+			meta,
 		});
 		await upgradedDocuments.close();