@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/export/actor-export.service.mjs

@@ -0,0 +1,267 @@
+import { j as map, k as makeBy, l as filter, p as flatMap } from "../Array-B4kuTQeW.mjs";
+import { n as log } from "../Console-BKHUkH6a.mjs";
+import { A as ensuring, At as provideContext, B as flatMap$1, C as catch_, Et as orDie, Gn as mergeAll, K as forEach, Kn as provide, Lt as retry, S as catchTags, T as context, Tt as option, U as fn, Vn as effect, Xt as succeed, Zt as succeedNone, _a as pick, aa as Service, dt as map$1, et as gen, ft as mapBoth, ht as mapError, lt as logWarning, nn as tapCause, tn as tap, u as asSome, x as catchTag } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { i as tag, n as exhaustive, s as value } from "../Match-CGPLZYrV.mjs";
+import { S as none, _ as isSome, d as fromUndefinedOr, h as isNone, i as filter$1, x as match } from "../Option-DkxSnBhp.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { I as Struct, pt as fromJsonString, st as encodeEffect, tt as decodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { f as replaceAll, u as padStart } from "../String-q5dcsVe4.mjs";
+import { a as BlobHashing, n as ArchivedActors, r as blobHashing } from "../hosted-runtime.layer-Cx3IPsEd.mjs";
+import { s as ExportSnapshot, t as AppName, u as OrganizationName } from "../cloud-client.adapter-Cy1BjDbG.mjs";
+import { ArchivedComputersJson, computersPath } from "../archive/akter-archive.schema.mjs";
+import { t as CloudClient } from "../cloud-client.adapter-DOVMoYAj.mjs";
+import { cloudUrl } from "../deploy/cloud-url.pure.mjs";
+import { ExportFailedError } from "./export-failed.errors.mjs";
+import { exportFailure, snapshotRetries } from "./export-failure.pure.mjs";
+import { orderedLines } from "./ordered-lines.pure.mjs";
+import { downloadedSnapshot } from "./snapshot-download.pure.mjs";
+// src/export/actor-export.service.ts
+const Target = Struct({
+	app: AppName,
+	organization: OrganizationName
+});
+const shardCount = 300;
+const firstShard = 1;
+const shardDigits = 3;
+const ownerOnlyFile = 384;
+const ownerOnlyFolder = 448;
+const emptyKey = "%";
+const dotsOnly = /^\.*$/u;
+const PendingText = fromJsonString(ExportSnapshot);
+const shards = makeBy(shardCount, (index) => index + firstShard);
+const keySegment = (key) => {
+	const encoded = encodeURIComponent(key);
+	if (encoded === "") return emptyKey;
+	if (dotsOnly.test(encoded)) return replaceAll(".", "%2E")(encoded);
+	return encoded;
+};
+/** A computer as the archive records it: its checkpoint, when it has one, never leaves the Cloud account. */
+const archivedComputer = ({ actor, checkpoint, key, ...computer }) => ({
+	...computer,
+	actor: {
+		key,
+		type: actor
+	},
+	...match(fromUndefinedOr(checkpoint), {
+		onNone: () => ({}),
+		onSome: (id) => ({ checkpoint: {
+			id,
+			portable: false
+		} })
+	})
+});
+const placed = fn("placed")(function* placed(out, shard, address) {
+	const path = yield* Path;
+	if (encodeURIComponent(address.actor) !== address.actor || dotsOnly.test(address.actor)) return yield* ExportFailedError.make({ message: "The API listed an actor name that is not a safe folder name." });
+	const folder = padStart(shardDigits, "0")(String(shard));
+	const home = path.join(out, "shards", folder, address.actor, keySegment(address.key));
+	return {
+		address,
+		database: path.join(home, "actor.db"),
+		files: path.join(home, "files"),
+		home,
+		name: `${address.actor}/${address.key}`,
+		partial: path.join(home, "actor.db.export"),
+		pending: path.join(home, "actor.db.export.json"),
+		stripping: path.join(home, "actor.db.strip.export")
+	};
+});
+const wipe = fn("wipe")(function* wipe(placing) {
+	const fs = yield* FileSystem;
+	return yield* forEach([
+		placing.partial,
+		placing.pending,
+		placing.stripping
+	], (file) => fs.remove(file, { force: true }), { discard: true });
+});
+const refused = fn("refused")(function* refused(placing, message) {
+	yield* wipe(placing);
+	return yield* ExportFailedError.make({ message });
+});
+const goneOrErased = (placing) => (cause) => value(cause).pipe(tag("ActorErasedError", () => succeedNone), tag("ExportSnapshotGoneError", (gone) => refused(placing, `The snapshot of ${placing.name} is gone (${gone.reason}). Run akter export again to start that actor over.`)), exhaustive);
+const pendingOf = fn("pendingOf")(function* pendingOf({ address, pending }) {
+	const fs = yield* FileSystem;
+	if (!(yield* fs.exists(pending))) return none();
+	const text = yield* fs.readFileString(pending);
+	const decoded = yield* option(decodeEffect(PendingText)(text));
+	return filter$1(decoded, (snapshot) => snapshot.actor === address.actor && snapshot.key === address.key);
+});
+const started = fn("started")(function* started({ cloud, placing, target }) {
+	yield* wipe(placing);
+	const snapshot = yield* cloud.request(cloud.client.actorsExportSnapshot(target.organization, target.app, { payload: placing.address }).pipe(retry(snapshotRetries), asSome, catchTags({ ActorsExportSnapshot410: (failure) => goneOrErased(placing)(failure.cause) })), "10 minutes").pipe(mapError(exportFailure(`Snapshot of ${placing.name}`)));
+	if (isNone(snapshot)) return snapshot;
+	if (snapshot.value.actor !== placing.address.actor || snapshot.value.key !== placing.address.key) return yield* ExportFailedError.make({ message: `The API returned a snapshot of another actor for ${placing.name}.` });
+	const fs = yield* FileSystem;
+	const text = yield* encodeEffect(PendingText)(snapshot.value);
+	yield* fs.writeFileString(placing.pending, text, { mode: ownerOnlyFile });
+	return snapshot;
+});
+const snapshotOf = fn("snapshotOf")(function* snapshotOf(job) {
+	const resumed = yield* pendingOf(job.placing);
+	if (isSome(resumed)) {
+		yield* job.say(`${job.placing.name}: resuming`);
+		return resumed;
+	}
+	return yield* started(job);
+});
+const databaseRange = ({ cloud, placing, target }, snapshot) => (range) => {
+	const params = {
+		...placing.address,
+		length: range.length,
+		offset: range.offset
+	};
+	return cloud.request(cloud.client.actorsExportRead(target.organization, target.app, snapshot.snapshot, { params }).pipe(retry(snapshotRetries), asSome, catchTag("ActorsExportRead410", (failure) => goneOrErased(placing)(failure.cause))), "2 minutes").pipe(mapError(exportFailure(`Download of ${placing.name}`)));
+};
+const skipErased = fn("skipErased")(function* skipErased({ placing, say }) {
+	yield* wipe(placing);
+	yield* FileSystem.use((fs) => fs.remove(placing.files, {
+		force: true,
+		recursive: true
+	}));
+	yield* say(`${placing.name}: erased, nothing to export`);
+	return "erased";
+});
+const erasedOr = (placing) => (failure) => goneOrErased(placing)(failure.cause);
+const filePage = ({ cloud, placing, target }, snapshot) => (after) => {
+	const from = match(after, {
+		onNone: () => ({}),
+		onSome: (sha256) => ({ after: sha256 })
+	});
+	const params = {
+		...placing.address,
+		...from
+	};
+	const listing = cloud.client.actorsExportFiles(target.organization, target.app, snapshot.snapshot, { params }).pipe(retry(snapshotRetries), asSome, catchTag("ActorsExportFiles410", erasedOr(placing)));
+	return cloud.request(listing, "30 seconds").pipe(mapError(exportFailure(`Listing the files of ${placing.name}`)));
+};
+const fileRange = ({ cloud, placing, target }, snapshot) => (file, range) => {
+	const params = {
+		...placing.address,
+		length: range.length,
+		offset: range.offset
+	};
+	const reading = cloud.client.actorsExportFileRead(target.organization, target.app, snapshot.snapshot, file.sha256, { params }).pipe(retry(snapshotRetries), asSome, catchTag("ActorsExportFileRead410", erasedOr(placing)));
+	return cloud.request(reading, "2 minutes").pipe(mapError(exportFailure(`Download of a file of ${placing.name}`)));
+};
+/** The verified database becomes the actor's `actor.db` only once it is stripped, which marks the actor done. */
+const stripped = fn("stripped")(function* stripped(placing) {
+	const fs = yield* FileSystem;
+	yield* ArchivedActors.strip(placing.stripping).pipe(tapCause(logWarning), catch_(() => refused(placing, `${placing.name}'s database could not be prepared for the archive.`)));
+	yield* fs.rename(placing.stripping, placing.database);
+	yield* fs.remove(placing.pending, { force: true });
+});
+const snapshotDownload = (job, snapshot, hashing) => {
+	const { name } = job.placing;
+	const refuse = (message) => refused(job.placing, message);
+	return {
+		database: {
+			...snapshot,
+			hashing,
+			name,
+			partial: job.placing.partial,
+			read: databaseRange(job, snapshot),
+			refuse,
+			say: job.say,
+			target: job.placing.stripping
+		},
+		files: {
+			folder: job.placing.files,
+			hashing,
+			name,
+			page: filePage(job, snapshot),
+			read: fileRange(job, snapshot),
+			refuse,
+			say: job.say
+		}
+	};
+};
+const fetched = fn("fetched")(function* fetched(job) {
+	yield* FileSystem.use((fs) => fs.makeDirectory(job.placing.home, {
+		mode: ownerOnlyFolder,
+		recursive: true
+	}));
+	const snapshot = yield* snapshotOf(job);
+	if (isNone(snapshot)) return yield* skipErased(job);
+	const hashing = yield* BlobHashing.use((hasher) => succeed(hasher.sha256));
+	const database = yield* downloadedSnapshot(snapshotDownload(job, snapshot.value, hashing));
+	if (isNone(database)) return yield* skipErased(job);
+	yield* stripped(job.placing);
+	return "exported";
+});
+const exportActor = fn("exportActor")(function* exportActor(job) {
+	if (yield* (yield* FileSystem).exists(job.placing.database)) {
+		yield* wipe(job.placing);
+		yield* job.say(`${job.placing.name}: already exported`);
+		return "kept";
+	}
+	return yield* fetched(job);
+});
+/** Shards listed at once: a sparse app's 300 listings take about 300 × 330 ms one at a time, about 3 s 32 at a time. */
+const shardsListedAtOnce = 32;
+const listShard = (run, shard) => run.cloud.request(run.cloud.client.actorsExportShard(run.target.organization, run.target.app, String(shard), {}), "30 seconds").pipe(mapBoth({
+	onFailure: exportFailure(`Listing shard ${shard}`),
+	onSuccess: (page) => ({
+		page,
+		shard
+	})
+}));
+/** Actors exported at once: a few, so a dense app goes faster while each snapshot still streams to disk. */
+const actorsAtOnce = 4;
+/**
+* Lists every shard first, 32 at a time, then exports their actors 4 at a time. The manifest, the archive and the
+* console lines keep shard order, as if each actor were exported in turn.
+*/
+const exportShards = fn("exportShards")(function* exportShards(run) {
+	const listed = yield* forEach(shards, (shard) => listShard(run, shard), { concurrency: shardsListedAtOnce });
+	const actors = flatMap(listed, ({ page, shard }) => map(page.actors, (address) => ({
+		address,
+		shard
+	})));
+	const lines = yield* orderedLines;
+	const outcomes = yield* forEach(actors, ({ address, shard }, index) => flatMap$1(placed(run.out, shard, address), (placing) => exportActor({
+		...run,
+		placing,
+		say: lines.say(index)
+	})).pipe(ensuring(lines.done(index))), { concurrency: actorsAtOnce });
+	return {
+		computers: flatMap(listed, ({ page }) => map(page.computers ?? [], archivedComputer)),
+		exported: filter(outcomes, (outcome) => outcome !== "erased").length
+	};
+});
+/** Writes the computers every shard listed into the staging folder, where packing reads them into the manifest. */
+const keepComputers = fn("keepComputers")(function* keepComputers(out, computers) {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const text = yield* orDie(encodeEffect(ArchivedComputersJson)(computers));
+	yield* fs.makeDirectory(out, {
+		mode: ownerOnlyFolder,
+		recursive: true
+	});
+	yield* fs.writeFileString(path.join(out, computersPath), text, { mode: ownerOnlyFile });
+});
+const runExport = fn("runExport")(function* runExport(options) {
+	const target = yield* decodeEffect(Target)(options).pipe(mapError(() => ExportFailedError.make({ message: "App and organization must be valid Cloud names." })));
+	const url = yield* cloudUrl(options.url);
+	const { apiKey } = options;
+	const out = yield* Path.use((path) => succeed(path.resolve(options.out)));
+	const cloud = yield* CloudClient.use((factory) => factory.connect({
+		apiKey,
+		url
+	})).pipe(tap((connected) => connected.signIn));
+	const { computers, exported } = yield* exportShards({
+		cloud,
+		out,
+		target
+	});
+	yield* keepComputers(out, computers);
+	yield* log(`Exported ${exported} actors to ${out}`);
+	return exported;
+});
+var ActorExport = class extends Service()("@akterjs/cli/export/actor-export.service/ActorExport", { make: gen(function* makeActorExport() {
+	const context$1 = yield* context().pipe(map$1(pick(BlobHashing, CloudClient, FileSystem, Path)));
+	return { run: (options) => provideContext(runExport(options), context$1) };
+}) }) {
+	static layer = effect(this, this.make).pipe(provide(mergeAll(CloudClient.layer, blobHashing)));
+};
+export { ActorExport };

package/dist/export/export-failed.errors.mjs

@@ -0,0 +1,4 @@
+import { F as String, z as TaggedError } from "../Schema-MiKt5K1v.mjs";
+// src/export/export-failed.errors.ts
+var ExportFailedError = class extends TaggedError()("ExportFailedError", { message: String }) {};
+export { ExportFailedError };

package/dist/export/export-failure.pure.mjs

@@ -0,0 +1,18 @@
+import { An as spaced } from "../Effect-CKFpqbmw.mjs";
+import { mt as is } from "../Schema-MiKt5K1v.mjs";
+import { DeployFailedError } from "../deploy/deploy-failed.errors.mjs";
+import { retryable, statusOf } from "../deploy/request-failure.pure.mjs";
+import { ExportFailedError } from "./export-failed.errors.mjs";
+// src/export/export-failure.pure.ts
+const snapshotRetries = {
+	schedule: spaced("250 millis"),
+	times: 3,
+	while: retryable
+};
+/** A failed Cloud request of an export step as the export's failure, naming the step and the HTTP status. */
+const exportFailure = (operation) => (failure) => {
+	if (is(ExportFailedError)(failure)) return failure;
+	if (is(DeployFailedError)(failure)) return ExportFailedError.make({ message: failure.message });
+	return ExportFailedError.make({ message: `${operation} failed (${statusOf(failure)}).` });
+};
+export { exportFailure, snapshotRetries };

package/dist/export/ordered-lines.pure.mjs

@@ -0,0 +1,43 @@
+import { o as empty } from "../Array-B4kuTQeW.mjs";
+import { n as log } from "../Console-BKHUkH6a.mjs";
+import { $t as suspend, K as forEach, dt as map, gn as void_ } from "../Effect-CKFpqbmw.mjs";
+import { a as remove, n as empty$1, o as set, r as get } from "../MutableHashMap-f8nW8AJR.mjs";
+import { n as empty$2, r as has, t as add } from "../MutableHashSet-_HI572Ya.mjs";
+import { f as getOrElse } from "../Option-DkxSnBhp.mjs";
+import { t as make } from "../Semaphore-DOVJ4ZGS.mjs";
+// src/export/ordered-lines.pure.ts
+const firstJob = 0;
+const one = 1;
+const printed = (lines) => forEach(lines, (line) => log(line), { discard: true });
+const sayWith = (printing) => (index) => (line) => suspend(() => {
+	if (index === printing.next) return log(line);
+	const kept = getOrElse(get(printing.kept, index), empty);
+	set(printing.kept, index, [...kept, line]);
+	return void_;
+});
+/** Moves past every finished job at the front, gathering what each job that becomes first has kept. */
+const advanced = (printing) => {
+	const lines = [];
+	while (has(printing.finished, printing.next)) {
+		printing.next += one;
+		lines.push(...getOrElse(get(printing.kept, printing.next), empty));
+		remove(printing.kept, printing.next);
+	}
+	return lines;
+};
+const orderedLines = map(make(one), (lock) => {
+	const printing = {
+		finished: empty$2(),
+		kept: empty$1(),
+		next: firstJob
+	};
+	const say = sayWith(printing);
+	return {
+		done: (index) => lock.withPermit(suspend(() => {
+			add(printing.finished, index);
+			return printed(advanced(printing));
+		})),
+		say: (index) => (line) => lock.withPermit(say(index)(line))
+	};
+});
+export { orderedLines };

package/dist/export/ranged-download.pure.mjs

@@ -0,0 +1,66 @@
+import { Gt as scoped, U as fn } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { S as none, _ as isSome, h as isNone, w as some } from "../Option-DkxSnBhp.mjs";
+import { W as runForEach } from "../Stream-bK9QIETN.mjs";
+// src/export/ranged-download.pure.ts
+const largestRead = 65536;
+const progressStep = 1048576;
+const ownerOnlyFile = 384;
+const checkedRange = fn("checkedRange")(function* checkedRange(download, offset) {
+	const length = Math.min(largestRead, download.bytes - offset);
+	const chunk = yield* download.read({
+		length,
+		offset
+	});
+	if (isSome(chunk) && chunk.value.byteLength !== length) return yield* download.refuse(`The API returned ${chunk.value.byteLength} bytes of ${download.name} where ${length} were expected.`);
+	return chunk;
+});
+const stepped = fn("stepped")(function* stepped({ download, file, hash }, offset) {
+	const chunk = yield* checkedRange(download, offset);
+	if (isNone(chunk)) return none();
+	yield* file.writeAll(chunk.value);
+	yield* hash.update(chunk.value);
+	const next = offset + chunk.value.byteLength;
+	if (Math.floor(next / progressStep) > Math.floor(offset / progressStep) || next === download.bytes) yield* download.say(`${download.name}: ${next} of ${download.bytes} bytes`);
+	return some(next);
+});
+const resumedHash = fn("resumedHash")(function* resumedHash(download) {
+	const fs = yield* FileSystem;
+	const hash = yield* download.hashing;
+	yield* runForEach(fs.stream(download.partial, { chunkSize: largestRead }), hash.update);
+	return hash;
+});
+const streamed = fn("streamed")(function* streamed(writing, from) {
+	let offset = some(from);
+	while (isSome(offset) && offset.value < writing.download.bytes) offset = yield* stepped(writing, offset.value);
+	yield* writing.file.sync;
+	if (isNone(offset)) return none();
+	const sha256 = yield* writing.hash.digest;
+	return some(sha256);
+});
+const written = fn("written")(function* written(download) {
+	const file = yield* (yield* FileSystem).open(download.partial, {
+		flag: "a",
+		mode: ownerOnlyFile
+	});
+	const { size } = yield* file.stat;
+	if (Number(size) > download.bytes) return yield* download.refuse(`${download.name}: the partial download is longer than its snapshot.`);
+	const hash = yield* resumedHash(download);
+	return yield* streamed({
+		download,
+		file,
+		hash
+	}, Number(size));
+});
+/**
+* Downloads the rest of the file, checks its SHA-256 and moves it to its target. None when the actor was erased while
+* it downloaded; a file that doesn't match is refused, so the next run starts the actor over.
+*/
+const rangedDownload = fn("rangedDownload")(function* rangedDownload(download) {
+	const sha256 = yield* scoped(written(download));
+	if (isNone(sha256)) return none();
+	if (sha256.value !== download.sha256) return yield* download.refuse(`${download.name} did not match its SHA-256. Run akter export again to start that actor over.`);
+	yield* FileSystem.use((fs) => fs.rename(download.partial, download.target));
+	return some(download.target);
+});
+export { rangedDownload };

package/dist/export/snapshot-download.pure.mjs

@@ -0,0 +1,86 @@
+import { C as isReadonlyArrayEmpty, j as map, l as filter, n as appendAll, r as contains, w as isReadonlyArrayNonEmpty } from "../Array-B4kuTQeW.mjs";
+import { K as forEach, U as fn, o as andThen } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { S as none, _ as isSome, d as fromUndefinedOr, h as isNone, w as some } from "../Option-DkxSnBhp.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { rangedDownload } from "./ranged-download.pure.mjs";
+// src/export/snapshot-download.pure.ts
+const ownerOnlyFolder = 448;
+/** Every page of the snapshot's files, in SHA-256 order; none when the actor was erased while they were listed. */
+const listed = fn("listed")(function* listed(files) {
+	let found = [];
+	let page = yield* files.page(none());
+	while (isSome(page)) {
+		found = appendAll(found, page.value.files);
+		const after = fromUndefinedOr(page.value.next);
+		if (isNone(after)) return some(found);
+		page = yield* files.page(after);
+	}
+	return none();
+});
+/** A file already in the folder was verified when it was written, since its name is its SHA-256. */
+const fetchedFile = fn("fetchedFile")(function* fetchedFile(files, file) {
+	const fs = yield* FileSystem;
+	const target = (yield* Path).join(files.folder, file.sha256);
+	if (yield* fs.exists(target)) return some(target);
+	const partial = `${target}.export`;
+	return yield* rangedDownload({
+		...file,
+		hashing: files.hashing,
+		name: `${files.name} file ${file.sha256}`,
+		partial,
+		read: (range) => files.read(file, range),
+		refuse: (message) => andThen(fs.remove(partial, { force: true }), files.refuse(message)),
+		say: files.say,
+		target
+	});
+});
+/**
+* Removes what the snapshot doesn't hold, such as an earlier snapshot's files or a partial download left by one, so
+* the archive carries only these.
+*/
+const pruned = fn("pruned")(function* pruned(files, kept) {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	if (isReadonlyArrayEmpty(kept)) return yield* fs.remove(files.folder, {
+		force: true,
+		recursive: true
+	});
+	const names = map(kept, (file) => file.sha256);
+	const present = yield* fs.readDirectory(files.folder);
+	const stale = filter(present, (name) => !contains(names, name));
+	return yield* forEach(stale, (name) => fs.remove(path.join(files.folder, name), { force: true }), { discard: true });
+});
+/** Downloads every listed file, in order; false when the actor was erased meanwhile. */
+const downloadedAll = fn("downloadedAll")(function* downloadedAll(files, listing) {
+	if (isReadonlyArrayNonEmpty(listing)) yield* FileSystem.use((fs) => fs.makeDirectory(files.folder, {
+		mode: ownerOnlyFolder,
+		recursive: true
+	}));
+	for (const file of listing) {
+		const target = yield* fetchedFile(files, file);
+		if (isNone(target)) return false;
+	}
+	return true;
+});
+/**
+* Downloads each file the snapshot holds into `<folder>/<sha256>`, resuming and verifying each like the database,
+* and leaves nothing else there. Returns how many files the actor has; none when it was erased meanwhile.
+*/
+const actorFiles = fn("actorFiles")(function* actorFiles(files) {
+	const listing = yield* listed(files);
+	if (isNone(listing)) return none();
+	if (!(yield* downloadedAll(files, listing.value))) return none();
+	yield* pruned(files, listing.value);
+	return some(listing.value.length);
+});
+/**
+* Downloads an actor's export snapshot: its files first, then its database, which comes last because the caller
+* takes a written database as the actor done. None when the actor was erased meanwhile.
+*/
+const downloadedSnapshot = fn("downloadedSnapshot")(function* downloadedSnapshot({ database, files }) {
+	const counted = yield* actorFiles(files);
+	if (isNone(counted)) return none();
+	return yield* rangedDownload(database);
+});
+export { downloadedSnapshot };

package/dist/history-runner.pure.mjs

@@ -0,0 +1,186 @@
+import { T as join } from "./Array-B4kuTQeW.mjs";
+import { appEntry } from "./app-entry.pure.mjs";
+// src/history-runner.pure.ts
+const recordLines = [
+	"const toJson = (schema, value) => Schema.encodeSync(Schema.toCodecJson(schema))(value);",
+	"const failureOf = (declaration, cause) =>",
+	"  Option.match(Cause.findErrorOption(cause), {",
+	"    onNone: () => ({ outcome: \"died\", defect: Cause.pretty(cause) }),",
+	"    onSome: (error) => ({ outcome: \"failed\", error: toJson(Schema.Union([declaration.error, HandlerFailedError]), error) }),",
+	"  });",
+	"const outcomeOf = (declaration, exit) =>",
+	"  Exit.match(exit, {",
+	"    onFailure: (cause) => failureOf(declaration, cause),",
+	"    onSuccess: (value) => ({ outcome: \"ok\", value: toJson(declaration.success, value) }),",
+	"  });",
+	"const declarationOf = (entry) => {",
+	"  if (entry.kind === \"created\") return { error: ActorAlreadyExistsError, payload: actor.create, success: Schema.Void };",
+	"  if (entry.kind !== \"result\") return actor.commands[entry.command];",
+	"  const job = actor.jobs[entry.job];",
+	"  return { error: Schema.Never, payload: Schema.Exit(job.successSchema, job.errorSchema, Schema.Defect()), success: Schema.Void };",
+	"};",
+	"const recordOf = (entry) => {",
+	"  const base = { seq: entry.seq, at: new Date(entry.at).toISOString(), command: entry.command, commandId: entry.commandId };",
+	"  if (entry.kind === \"unreadable\") return { ...base, unreadable: entry.reason };",
+	"  const declaration = declarationOf(entry);",
+	"  const payload = entry.kind === \"result\" ? entry.result : entry.payload;",
+	"  return { ...base, principal: entry.principal, payload: toJson(declaration.payload, payload), ...outcomeOf(declaration, entry.exit) };",
+	"};",
+	"const shown = (value) => (value === undefined ? \"\" : \" \" + JSON.stringify(value));",
+	"const textOf = (record) => {",
+	"  const head = record.at + \"  \" + record.command;",
+	"  if (\"unreadable\" in record) return head + \"  unreadable: \" + record.unreadable;",
+	"  const said = head + \" \" + shown(record.principal) + \" \" + shown(record.payload);",
+	"  if (record.outcome === \"ok\") return said + \"  -> ok\" + shown(record.value);",
+	"  if (record.outcome === \"died\") return said + \"  -> died \" + record.defect;",
+	"  const { _tag, ...fields } = record.error;",
+	"  return said + \"  -> failed \" + _tag + (Object.keys(fields).length === 0 ? \"\" : shown(fields));",
+	"};"
+];
+const pageLines = (json) => [
+	`const render = ${json} ? JSON.stringify : textOf;`,
+	"const coverageOf = (coveredSince) => {",
+	"  const iso = new Date(coveredSince).toISOString();",
+	`  return ${json} ? JSON.stringify({ coveredSince: iso }) : "complete since " + iso;`,
+	"};",
+	"const printed = { coveredSince: 0 };",
+	"const printPage = (page) =>",
+	"  Effect.sync(() => {",
+	"    if (page.coveredSince !== printed.coveredSince) {",
+	"      printed.coveredSince = page.coveredSince;",
+	"      console.log(coverageOf(page.coveredSince));",
+	"    }",
+	"    for (const entry of page.entries) console.log(render(recordOf(entry)));",
+	"  });"
+];
+const verifyLines = [
+	"const timeOf = (point) => new Date(point.at).toISOString();",
+	"const windowText = (window) =>",
+	"  Option.match(Option.all({ first: window.first, last: window.last }), {",
+	"    onNone: () => \"no commands\",",
+	"    onSome: ({ first, last }) => window.commands + \" commands, seq \" + first.seq + \" to \" + last.seq + \", \" + timeOf(first) + \" to \" + timeOf(last),",
+	"  });",
+	"const actualText = (actual) =>",
+	"  actual.kind === \"journaled\" ? actual.exit : \"refused \" + actual.error._tag + \": \" + actual.error.message;",
+	"const reportText = (report) => {",
+	"  const replayed = \"replayed \" + windowText(report.window) + \" against the current handlers\";",
+	"  return Option.match(report.difference, {",
+	"    onNone: () => replayed + \": no difference\",",
+	"    onSome: (difference) =>",
+	"      [",
+	"        replayed,",
+	"        \"first difference at seq \" + difference.seq + \": \" + difference.command + \" \" + difference.commandId + \" at \" + timeOf(difference),",
+	"        \"  expected \" + difference.expected,",
+	"        \"  actual   \" + actualText(difference.actual),",
+	String.raw`      ].join("\n"),`,
+	"  });",
+	"};",
+	"const pointJson = (point) => Option.getOrNull(Option.map(point, (found) => ({ seq: found.seq, at: timeOf(found) })));",
+	"const actualJson = (actual) =>",
+	"  actual.kind === \"journaled\"",
+	"    ? { kind: \"journaled\", exit: JSON.parse(actual.exit) }",
+	"    : { kind: \"refused\", error: { _tag: actual.error._tag, message: actual.error.message } };",
+	"const differenceJson = (difference) => ({",
+	"  seq: difference.seq,",
+	"  at: timeOf(difference),",
+	"  command: difference.command,",
+	"  commandId: difference.commandId,",
+	"  expected: JSON.parse(difference.expected),",
+	"  actual: actualJson(difference.actual),",
+	"});",
+	"const reportJson = (report) =>",
+	"  JSON.stringify({",
+	"    window: { commands: report.window.commands, first: pointJson(report.window.first), last: pointJson(report.window.last) },",
+	"    difference: Option.getOrNull(Option.map(report.difference, differenceJson)),",
+	"  });",
+	"const notHosted = (error) =>",
+	"  Effect.sync(() => {",
+	"    console.error(\"akter history: the app layer does not host \" + error.actor);",
+	"    process.exitCode = 1;",
+	"  });",
+	"const pruned = (error) =>",
+	"  Effect.sync(() => {",
+	"    console.error(\"akter history: --verify replays from the first command, but the history of \" + address + \" is complete only since \" + new Date(error.coveredSince).toISOString() + \", because a retention pruned what came before.\");",
+	"    process.exitCode = 1;",
+	"  });",
+	"const printed = (report) =>",
+	"  Effect.sync(() => {",
+	"    console.log(render(report));",
+	"    if (Option.isSome(report.difference)) process.exitCode = 1;",
+	"  });"
+];
+const streamLines = ({ directory, json, since }) => [
+	...recordLines,
+	...pageLines(json),
+	`const options = ${since} === null ? {} : { since: ${since} };`,
+	"",
+	"await Effect.runPromise(",
+	"  decodedKey.pipe(",
+	"    Effect.flatMap((key) => Stream.runForEach(actor.historyStream(key, options), printPage)),",
+	"    Effect.catchTags({ ActorUnavailableError: unreadableStore, InvalidRequestError: unreadableStore }),",
+	`    Effect.provide(Akter.local(${directory}).pipe(Layer.provide(app.layer), Layer.provide(Akter.jobs))),`,
+	"  ),",
+	");"
+];
+const replayLines = ({ directory, json }) => [
+	...verifyLines,
+	`const render = ${json} ? reportJson : reportText;`,
+	"",
+	"await Effect.runPromise(",
+	"  decodedKey.pipe(",
+	`    Effect.flatMap((key) => Verify.replay(app.layer.pipe(Layer.provide(Akter.jobs)), { actor, directory: ${directory}, key })),`,
+	"    Effect.flatMap(printed),",
+	"    Effect.catchTags({ ActorNotRegisteredError: notHosted, ActorUnavailableError: unreadableStore, HistoryPrunedError: pruned, InvalidRequestError: unreadableStore }),",
+	"  ),",
+	");"
+];
+const bodyOf = ({ directory, json, since, verify }) => {
+	if (verify) return replayLines({
+		directory,
+		json
+	});
+	return streamLines({
+		directory,
+		json,
+		since
+	});
+};
+const historyRunner = ({ address, directory, entry, json, since, verify }) => join([
+	"import { Cause, Effect, Exit, Layer, Option, Schema, Stream } from \"effect\";",
+	"import { ActorAlreadyExistsError, Akter, HandlerFailedError, Verify } from \"@akterjs/effect\";",
+	...appEntry({
+		command: "history",
+		entry
+	}),
+	"",
+	`const address = ${address};`,
+	"const slash = address.indexOf(\"/\");",
+	"const actor = app.actors.find((each) => each.name === address.slice(0, slash));",
+	"const keyText = address.slice(slash + 1);",
+	"const usage = (line) => {",
+	"  console.error(\"akter history: \" + line);",
+	"  process.exit(2);",
+	"};",
+	"",
+	"if (slash < 1 || actor === undefined) {",
+	"  usage(address + \" names no actor of the app. Name one as <Actor>/<key>, where <Actor> is one of: \" + app.actors.map((each) => each.name).join(\", \"));",
+	"}",
+	"",
+	"const unreadableStore = (error) =>",
+	"  Effect.sync(() => {",
+	"    console.error(\"akter history: could not read \" + address + \": \" + error.message);",
+	"    process.exitCode = 1;",
+	"  });",
+	"const decodedKey = Schema.decodeUnknownEffect(actor.key)(keyText).pipe(",
+	"  Effect.catchTag(\"SchemaError\", (issue) => Effect.sync(() => usage(keyText + \" is not a key of \" + actor.name + \": \" + issue.message))),",
+	");",
+	"",
+	...bodyOf({
+		directory,
+		json,
+		since,
+		verify
+	}),
+	""
+], "\n");
+export { historyRunner };