@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/operations-invocation-test-C75T6zn3.js

@@ -0,0 +1,523 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, hc as isCardErrorJSONAPI } from "./runtime-common-ClpqhbwG.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { a as CardDef, d as FileDef } from "./card-api-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+//#region tests/integration/operations-invocation-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+var loader;
+var operations;
+var REPORT_MODULE = `
+  import {
+    contains,
+    containsMany,
+    field,
+    linksToMany,
+    CardDef,
+    Component,
+    FieldDef,
+  } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+  import { operation, params, card, linkTo } from "@cardstack/base/operations";
+
+  export class ReportComment extends FieldDef {
+    @field body = contains(StringField);
+    @field postedBy = contains(StringField);
+  }
+
+  export class Activity extends CardDef {
+    @field headline = contains(StringField);
+    static isolated = class Isolated extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static embedded = class Embedded extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static fitted = class Fitted extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+  }
+
+  export class Report extends CardDef {
+    @field headline = contains(StringField);
+    @field status = contains(StringField);
+    @field comments = containsMany(ReportComment);
+    @field activities = linksToMany(() => Activity);
+
+    @operation static escalate = {
+      base: 'transform',
+      set: { status: 'escalated' },
+    };
+
+    @operation static addComment = {
+      base: 'transform',
+      params: { body: StringField },
+      append: { to: 'comments', value: { body: params('body') } },
+    };
+
+    @operation static addActivity = {
+      base: 'transform',
+      params: { activity: linkTo(() => Activity) },
+      append: { to: 'activities', value: card(params('activity')) },
+    };
+
+    @operation static createActivity = {
+      base: 'create',
+      of: Activity,
+      params: { headline: StringField },
+      fill: { headline: params('headline') },
+    };
+
+    @operation static openReports = {
+      base: 'query',
+      query: { filter: { on: () => Report, eq: { status: 'open' } } },
+    };
+
+    static isolated = class Isolated extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static embedded = class Embedded extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static fitted = class Fitted extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+  }
+`;
+function reportRef() {
+	return {
+		module: `${testRealmURL}report`,
+		name: "Report"
+	};
+}
+function reportFile(headline) {
+	return { data: {
+		type: "card",
+		attributes: {
+			headline,
+			status: "open",
+			comments: []
+		},
+		meta: { adoptsFrom: reportRef() }
+	} };
+}
+function realmContents() {
+	return {
+		"report.gts": REPORT_MODULE,
+		"report-transformed.json": reportFile("Quarterly Review"),
+		"report-read.json": reportFile("Read Me"),
+		"report-deleted.json": reportFile("Going Away"),
+		"report-updated.json": reportFile("Before"),
+		"report-appended.json": reportFile("Appended To"),
+		"report-batched.json": reportFile("Batched"),
+		"report-refused.json": reportFile("Refused"),
+		"report-created-from.json": reportFile("Creator"),
+		"report-grouped.json": reportFile("Grouped"),
+		"report-typed.json": reportFile("Typed"),
+		"notes.md": "# Notes\n"
+	};
+}
+function recordingTransport(opts) {
+	let sent = [];
+	let transport = {
+		async send(realmURL, method, envelope) {
+			let request = {
+				realmURL,
+				method,
+				envelope
+			};
+			sent.push(request);
+			let { answer } = opts ?? {};
+			if (typeof answer === "function") return answer(request);
+			return answer ?? { "atomic:results": [] };
+		},
+		defaultWritableRealm() {
+			return opts?.defaultRealm;
+		}
+	};
+	globalThis._CARDSTACK_OPERATIONS_TRANSPORT = transport;
+	return {
+		sent,
+		transport
+	};
+}
+(0, import_qunit.module)("Integration | operations invocation", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupCardLogs(hooks, async () => getService("loader-service").loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	let adapter;
+	let hostTransport;
+	hooks.beforeEach(async function() {
+		({adapter} = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: realmContents()
+		}));
+		loader = getService("loader-service").loader;
+		({operations} = await loader.import("@cardstack/base/operations"));
+		await getService("realm").login(testRealmURL);
+		getService("operations");
+		hostTransport = globalThis._CARDSTACK_OPERATIONS_TRANSPORT;
+	});
+	hooks.afterEach(function() {
+		globalThis._CARDSTACK_OPERATIONS_TRANSPORT = hostTransport;
+		delete globalThis.__boxelPrerenderApp;
+	});
+	async function cardAt(localPath) {
+		return loaded(await getService("store").get(`${testRealmURL}${localPath}`), localPath);
+	}
+	async function fileAt(localPath) {
+		return loaded(await getService("store").get(`${testRealmURL}${localPath}`, { type: "file-meta" }), localPath);
+	}
+	function loaded(instance, at) {
+		if (!instance || isCardErrorJSONAPI(instance)) throw new Error(`expected ${at} to load, got ${JSON.stringify(instance)}`);
+		return instance;
+	}
+	async function storedCard(localPath) {
+		let file = await adapter.openFile(localPath);
+		if (!file) throw new Error(`${localPath} is not in the realm`);
+		return JSON.parse(file.content);
+	}
+	async function storedText(localPath) {
+		let file = await adapter.openFile(localPath);
+		if (!file) throw new Error(`${localPath} is not in the realm`);
+		return file.content;
+	}
+	(0, import_qunit.module)("one operation at a time", function() {
+		(0, import_qunit.test)("a named transform answers with the card it wrote, and the card holds the change", async function(assert) {
+			let report = await cardAt("report-transformed");
+			let result = await operations(report).addComment({ body: "Reviewed and approved." });
+			assert.strictEqual(result.id, `${testRealmURL}report-transformed`, "the result names the card the operation ran against");
+			assert.ok(result.version, "the result carries the version it now holds");
+			assert.ok(result.lastModified > 0, "and when the card was last written");
+			let comments = (await storedCard("report-transformed.json")).data.attributes.comments;
+			assert.strictEqual(comments.length, 1, "one comment was appended");
+			assert.strictEqual(comments[0].body, "Reviewed and approved.", "carrying the value the payload supplied, as the declaration describes");
+		});
+		(0, import_qunit.test)("a write carries a client request id to the realm, and claims no card it did not supply", async function(assert) {
+			let report = await cardAt("report-transformed");
+			let broadcast = [];
+			let realmEvent = adapter.broadcastRealmEvent.bind(adapter);
+			adapter.broadcastRealmEvent = async (...args) => {
+				broadcast.push(args[0]);
+				return realmEvent(...args);
+			};
+			let { clientRequestIds } = getService("card-service");
+			let before = new Set(clientRequestIds.values());
+			await operations(report).escalate();
+			let ids = broadcast.map((event) => event?.clientRequestId).filter(Boolean);
+			assert.strictEqual(ids.length, 1, "one write, one request id");
+			assert.true(String(ids[0]).startsWith("instance:"), `the realm received the id under the host's own prefix: ${ids[0]}`);
+			let added = [...clientRequestIds.values()].filter((id) => !before.has(id));
+			assert.deepEqual(added, ids, "the id the realm received is the one registered here");
+			let claimed = broadcast.map((event) => event?.clientAuthored).filter((named) => named !== void 0);
+			assert.strictEqual(claimed.length, 1, "the write answered which of its cards carried our content");
+			assert.deepEqual(claimed[0], [], "and answered that none of them did, so nothing about this pass is skipped");
+		});
+		(0, import_qunit.test)("a read answers with the document", async function(assert) {
+			let report = await cardAt("report-read");
+			let document = await operations(report).read();
+			assert.strictEqual(document.data.id, `${testRealmURL}report-read`, "the document is the card that was read");
+			assert.strictEqual(document.data.attributes.headline, "Read Me", "and it carries the card values");
+		});
+		(0, import_qunit.test)("a write from a bucket that skips the index wait answers ahead of its indexing", async function(assert) {
+			let report = await cardAt("report-transformed");
+			let result = await operations(report, { skipIndexWait: true }).addComment({ body: "Noted without waiting." });
+			assert.true(result.indexPending, "the answer says indexing is pending");
+			assert.strictEqual(result.generation, null, "and so names no generation");
+			let comments = (await storedCard("report-transformed.json")).data.attributes.comments;
+			assert.strictEqual(comments[comments.length - 1].body, "Noted without waiting.", "the write is in the realm");
+		});
+		(0, import_qunit.test)("a delete answers with nothing left to describe", async function(assert) {
+			let report = await cardAt("report-deleted");
+			let result = await operations(report).delete();
+			assert.strictEqual(result, null, "a delete reports no state");
+			assert.false(await adapter.exists("report-deleted.json"), "and the card is gone from the realm");
+		});
+		(0, import_qunit.test)("a base update merges the values it is given", async function(assert) {
+			let report = await cardAt("report-updated");
+			let result = await operations(report).update({ attributes: { headline: "After" } });
+			assert.strictEqual(result.id, `${testRealmURL}report-updated`);
+			let stored = await storedCard("report-updated.json");
+			assert.strictEqual(stored.data.attributes.headline, "After", "the merged value reached the stored card");
+			assert.strictEqual(stored.data.attributes.status, "open", "and a value the patch did not name is left as it was");
+		});
+		(0, import_qunit.test)("appendContainsMany adds to a collection without reading the card", async function(assert) {
+			let report = await cardAt("report-appended");
+			let result = await operations(report).appendContainsMany({
+				field: "comments",
+				items: [{
+					body: "Appended.",
+					postedBy: "@someone:localhost"
+				}]
+			});
+			assert.strictEqual(result.id, `${testRealmURL}report-appended`);
+			let stored = await storedCard("report-appended.json");
+			assert.deepEqual(stored.data.attributes.comments, [{
+				body: "Appended.",
+				postedBy: "@someone:localhost"
+			}]);
+		});
+		(0, import_qunit.test)("a class-scoped create mints a card in the realm it was given", async function(assert) {
+			let { Activity } = await loader.import(`${testRealmURL}report`);
+			let result = await operations(Activity).create({ headline: "Lab safety" }, { realm: testRealmURL });
+			assert.ok(result.id.startsWith(testRealmURL), `the new card was minted in the realm it was given: ${result.id}`);
+			let stored = await storedCard(`${result.id.slice(testRealmURL.length)}.json`);
+			assert.strictEqual(stored.data.attributes.headline, "Lab safety", "the field values the caller supplied reached the new card");
+			assert.strictEqual(stored.data.meta.adoptsFrom.name, "Activity", "and its type came from the class the call was made on");
+			assert.true(String(stored.data.meta.adoptsFrom.module).endsWith("report"), `naming the module that exports it: ${stored.data.meta.adoptsFrom.module}`);
+		});
+		(0, import_qunit.test)("the transport lands a create with no realm where the store would", async function(assert) {
+			assert.strictEqual(getService("operations").defaultWritableRealm(), testRealmURL, "a class-scoped create with no realm lands in the realm this session writes to");
+		});
+		(0, import_qunit.test)("a declared create mints its own type, anchored on the card it was invoked on", async function(assert) {
+			let report = await cardAt("report-created-from");
+			let stored = await storedCard(`${(await operations(report).createActivity({ headline: "Lab safety" })).id.slice(testRealmURL.length)}.json`);
+			assert.strictEqual(stored.data.attributes.headline, "Lab safety", "the declaration's fill wrote the new card's values");
+			assert.strictEqual(stored.data.meta.adoptsFrom.name, "Activity", "and what it minted is the type its declaration names, not the card it was invoked on");
+		});
+		(0, import_qunit.test)("an operation on a card that was never saved is refused before any request", async function(assert) {
+			let { Report } = await loader.import(`${testRealmURL}report`);
+			let unsaved = new Report({ headline: "Unsaved" });
+			let { sent } = recordingTransport();
+			await assert.rejects(operations(unsaved).escalate(), /no realm yet|never been saved/, "a card with no stored state has nothing for an operation to run against");
+			assert.strictEqual(sent.length, 0, "and nothing was sent");
+		});
+		(0, import_qunit.test)("a write cannot run in a render, and a read still can", async function(assert) {
+			let report = await cardAt("report-refused");
+			globalThis.__boxelPrerenderApp = true;
+			await assert.rejects(operations(report).escalate(), /cannot run in a render/, "a write from a render would wait on the worker the render is holding");
+			let stored = await storedCard("report-refused.json");
+			assert.strictEqual(stored.data.attributes.status, "open", "and the card is as it was");
+			let document = await operations(report).read();
+			assert.strictEqual(document.data.id, `${testRealmURL}report-refused`, "a read from the same render is carried out");
+		});
+		(0, import_qunit.test)("an environment with no transport says so rather than half-working", async function(assert) {
+			let report = await cardAt("report-read");
+			delete globalThis._CARDSTACK_OPERATIONS_TRANSPORT;
+			assert.throws(() => operations(report), /no operations transport is available/, "an operation is carried out over HTTP, which the host supplies — in node there is nothing to register");
+		});
+		(0, import_qunit.test)("stored bytes are reached somewhere other than a batch", async function(assert) {
+			let report = await cardAt("report-read");
+			let bucket = operations(report);
+			assert.strictEqual(bucket.readSource, void 0, "a stored-bytes read has no member: the card source and byte routes serve it");
+			assert.strictEqual(bucket.transform, void 0, "and a bare transform has none either: a transform runs a program, which a batch entry cannot carry");
+			assert.strictEqual(bucket.create, void 0, "a create targets a type, so it is invoked on the class");
+			assert.strictEqual(bucket.openReports, void 0, "a saved search reads a collection of a type, so it is invoked on the class as well");
+			let { Report } = await loader.import(`${testRealmURL}report`);
+			let savedSearch = operations(Report).openReports;
+			assert.strictEqual(typeof savedSearch, "function", "a declared query is invocable on the class that declares it");
+			assert.strictEqual(typeof savedSearch.query, "function", "and answers the wire query it resolves to, for a card that renders the rows itself");
+		});
+	});
+	(0, import_qunit.module)("the entry point's own typing", function() {
+		(0, import_qunit.test)("the ordinary spelling compiles, and answers what its type says", async function(assert) {
+			let report = await cardAt("report-typed");
+			let nearby = await cardAt("report-read");
+			let { Report } = await loader.import(`${testRealmURL}report`);
+			let result = await operations(report).addComment({ body: "Typed straight through." });
+			assert.strictEqual(result.id, `${testRealmURL}report-typed`, "the lean result is typed as one, and names the card it wrote");
+			await operations(report).atomic((b) => {
+				b.on(nearby).escalate();
+			});
+			let stored = await storedCard("report-read.json");
+			assert.strictEqual(stored.data.attributes.status, "escalated", "a card named through on() carries its operations by name too");
+			let created = await operations(Report).create({ headline: "From class" });
+			assert.ok(created.id.startsWith(testRealmURL), `a class-scoped create answers with the minted id: ${created.id}`);
+		});
+	});
+	(0, import_qunit.module)("a file's operations", function() {
+		(0, import_qunit.test)("a file reads its metadata document, replaces its content, and takes an appended line", async function(assert) {
+			let notes = await fileAt("notes.md");
+			let bucket = operations(notes);
+			let document = await bucket.read();
+			assert.strictEqual(document.data.attributes.name, "notes.md", "a file read answers with the metadata document");
+			let replaced = await bucket.update({ content: "# Replaced\n" });
+			assert.ok(replaced.version, "the write reports the content it now holds");
+			assert.strictEqual(await storedText("notes.md"), "# Replaced\n", "and the file holds exactly what it was given");
+			await bucket.appendLine({ line: "one more line" });
+			assert.strictEqual(await storedText("notes.md"), "# Replaced\none more line\n", "an appended line is newline-terminated and lands at the end");
+		});
+		(0, import_qunit.test)("a file carries its reads and the writes that work on its bytes, and nothing else", async function(assert) {
+			let notes = await fileAt("notes.md");
+			let bucket = operations(notes);
+			assert.strictEqual(typeof bucket.read, "function", "read");
+			assert.strictEqual(typeof bucket.update, "function", "update");
+			assert.strictEqual(typeof bucket.appendLine, "function", "appendLine");
+			for (let absent of [
+				"create",
+				"delete",
+				"transform",
+				"atomic",
+				"appendContainsMany",
+				"readSource"
+			]) assert.strictEqual(bucket[absent], void 0, `a file's bucket carries no ${absent}`);
+		});
+	});
+	(0, import_qunit.module)("a batch", function() {
+		(0, import_qunit.test)("a create-and-link batch answers with the minted id, and both entries commit together", async function(assert) {
+			let report = await cardAt("report-batched");
+			let { Activity } = await loader.import(`${testRealmURL}report`);
+			let [created] = await operations(report).atomic((b) => {
+				let activity = b.create(Activity, { headline: "Lab safety" });
+				b.addActivity({ activity });
+				return [activity];
+			});
+			assert.ok(created.id.startsWith(testRealmURL), `the create answers with the id the realm minted: ${created.id}`);
+			let lid = created.lid ?? "";
+			let namedByThisBatch = lid.endsWith("_1");
+			assert.true(namedByThisBatch, `beside the local id the batch named it with, which is the batch's own name and the card's position in it: ${lid}`);
+			let mintedFromThatName = created.id.endsWith(lid);
+			assert.true(mintedFromThatName, "and the realm minted the URL from that name, so the two agree");
+			let stored = await storedCard("report-batched.json");
+			let links = Object.values(stored.data.relationships ?? {}).map((relationship) => relationship?.links?.self);
+			assert.true(links.some((link) => link?.endsWith(created.id.slice(testRealmURL.length))), `the second entry linked the card the first minted: ${JSON.stringify(links)}`);
+			let activity = await storedCard(`${created.id.slice(testRealmURL.length)}.json`);
+			assert.strictEqual(activity.data.attributes.headline, "Lab safety", "and the minted card holds what the batch described");
+		});
+		(0, import_qunit.test)("a parallel group commits its members together", async function(assert) {
+			let report = await cardAt("report-grouped");
+			let { Activity } = await loader.import(`${testRealmURL}report`);
+			let [group] = await operations(report).atomic((b) => {
+				return [b.parallel((p) => {
+					return [p.create(Activity, { headline: "Lab safety" }), p.addComment({ body: "Both or neither." })];
+				})];
+			});
+			let [created, appended] = group;
+			assert.ok(created.id.startsWith(testRealmURL), `the group's create minted a card: ${created.id}`);
+			assert.strictEqual(appended.id, `${testRealmURL}report-grouped`, "and its sibling wrote the group's anchor card");
+			let comments = (await storedCard("report-grouped.json")).data.attributes.comments;
+			assert.strictEqual(comments.length, 1, "the append landed");
+			assert.strictEqual(comments[0].body, "Both or neither.");
+			let activity = await storedCard(`${created.id.slice(testRealmURL.length)}.json`);
+			assert.strictEqual(activity.data.attributes.headline, "Lab safety", "and so did the card the group minted, in the same commit");
+		});
+		(0, import_qunit.test)("a batch that targets a card in another realm is refused before any request", async function(assert) {
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: testRealm2URL,
+				contents: { "elsewhere.json": { data: {
+					type: "card",
+					attributes: {
+						headline: "Elsewhere",
+						status: "open"
+					},
+					meta: { adoptsFrom: reportRef() }
+				} } }
+			});
+			await getService("realm").login(testRealm2URL);
+			({operations} = await getService("loader-service").loader.import("@cardstack/base/operations"));
+			let elsewhere = loaded(await getService("store").get(`${testRealm2URL}elsewhere`), "test2/elsewhere");
+			let report = await cardAt("report-refused");
+			let { sent } = recordingTransport();
+			await assert.rejects(operations(report).atomic((b) => {
+				b.on(elsewhere).escalate();
+			}), /a batch commits to one realm/, "a batch commits under one realm write lock, so it cannot reach another realm");
+			assert.strictEqual(sent.length, 0, "and nothing was sent");
+		});
+	});
+});
+(0, import_qunit.module)("Integration | operations invocation types", function(hooks) {
+	setupRenderingTest(hooks);
+	setupCardLogs(hooks, async () => getService("loader-service").loader.import("@cardstack/base/card-api"));
+	setupMockMatrix(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	(0, import_qunit.test)("an operation takes the payload its declaration types, and answers by the behavior it is built on", async function(assert) {
+		let { operation, params, getDeclaredOperations } = await loader.import("@cardstack/base/operations");
+		class Report extends CardDef {
+			static {
+				decorateFieldV2(this, "addComment", [operation], function() {
+					return {
+						base: "transform",
+						params: { body: string_default },
+						append: {
+							to: "comments",
+							value: { body: params("body") }
+						}
+					};
+				});
+			}
+			#addComment = (initializeDeferredDecorator(this, "addComment"), void 0);
+			static {
+				decorateFieldV2(this, "archive", [operation], function() {
+					return { base: "delete" };
+				});
+			}
+			#archive = (initializeDeferredDecorator(this, "archive"), void 0);
+		}
+		class Activities extends CardDef {
+			static {
+				decorateFieldV2(this, "createActivity", [operation], function() {
+					return {
+						base: "create",
+						of: () => Activities,
+						params: { headline: string_default },
+						fill: { headline: params("headline") }
+					};
+				});
+			}
+			#createActivity = (initializeDeferredDecorator(this, "createActivity"), void 0);
+		}
+		class Reports extends CardDef {
+			static {
+				decorateFieldV2(this, "openReports", [operation], function() {
+					return {
+						base: "query",
+						query: { filter: {
+							on: () => Reports,
+							eq: { status: "open" }
+						} }
+					};
+				});
+			}
+			#openReports = (initializeDeferredDecorator(this, "openReports"), void 0);
+		}
+		assert.deepEqual(Object.keys(getDeclaredOperations(Reports)), ["openReports"], "and the reader agrees with the type about the declared query");
+		assert.deepEqual(Object.keys(getDeclaredOperations(Activities)), ["createActivity"], "and the reader agrees with the type about the declared create");
+		class Notes extends FileDef {
+			static {
+				decorateFieldV2(this, "appendAudit", [operation], function() {
+					return {
+						base: "appendLine",
+						params: { line: string_default }
+					};
+				});
+			}
+			#appendAudit = (initializeDeferredDecorator(this, "appendAudit"), void 0);
+		}
+		assert.deepEqual(Object.keys(getDeclaredOperations(Notes)), ["appendAudit"], "and the reader agrees with the type about what the file def declares");
+		assert.ok(Report, "the declarations are read off the class");
+	});
+	(0, import_qunit.test)("a batch's results are typed from the handles the builder returns", async function(assert) {
+		let { operation, params, linkTo } = await loader.import("@cardstack/base/operations");
+		class Activity extends CardDef {}
+		class Classroom extends CardDef {
+			static {
+				decorateFieldV2(this, "addActivity", [operation], function() {
+					return {
+						base: "transform",
+						params: { activity: linkTo(() => Activity) },
+						append: {
+							to: "activities",
+							value: params("activity")
+						}
+					};
+				});
+			}
+			#addActivity = (initializeDeferredDecorator(this, "addActivity"), void 0);
+		}
+		assert.ok(Classroom, "the batch surface is typed from the declarations");
+	});
+});
+//#endregion