@bjornpagen/bumbledb-log 1.2.1 → 1.3.1

package/dist/machine.js

@@ -78,17 +78,6 @@ function healthOf(operation, wire) {
     }
     return { kind: "unavailable", error: errorOf(operation, wire.error) };
 }
-function phaseOf(operation, wire) {
-    switch (wire) {
-        case "prepared":
-        case "dispatchedUnresolved":
-        case "confirmed":
-        case "provedNonpublication":
-            return wire;
-        default:
-            throw invalidInput(operation);
-    }
-}
 function inspectionOf(wire) {
     return {
         identity: identityOf(wire.identity),
@@ -277,40 +266,10 @@ function creationWire(operation, creation) {
         artifact: creation.artifact
     };
 }
-function snapshotsField(operation, plans) {
-    // Base schema snapshot first, then each entry's target: entries + 1 rows.
-    // Empty source still supplies the empty-schema render — never optional.
-    if (!Array.isArray(plans.snapshots) || plans.snapshots.length !== plans.manifest.entries.length + 1) {
-        throw invalidInput(operation);
-    }
-    return { snapshots: plans.snapshots.map((snapshot) => checkedString(operation, snapshot, 4 << 20)) };
-}
-function plansWire(operation, plans) {
-    if (plans.manifest.entries.length !== plans.plans.length || plans.manifest.entries.length > 4096) {
-        throw invalidInput(operation);
-    }
-    return {
-        ...snapshotsField(operation, plans),
-        manifestVersion: checkedNonNegative(operation, plans.manifest.manifestVersion, 0xffff),
-        planVersion: checkedNonNegative(operation, plans.manifest.planVersion, 0xffff),
-        baseSchemaId: checkedString(operation, plans.manifest.baseSchemaId, 64),
-        basePrefixDigest: checkedString(operation, plans.manifest.basePrefixDigest, 64),
-        entries: plans.manifest.entries.map((entry) => ({
-            sequence: checkedString(operation, entry.sequence, 20),
-            id: checkedString(operation, entry.id, 64),
-            fromSchemaId: checkedString(operation, entry.fromSchemaId, 64),
-            toSchemaId: checkedString(operation, entry.toSchemaId, 64),
-            planDigest: checkedString(operation, entry.planDigest, 64),
-            prefixDigest: checkedString(operation, entry.prefixDigest, 64)
-        })),
-        // Inert canonical transport of the generated plan data; the native
-        // migration codec is the one canonicalization/digest authority.
-        plans: plans.plans.map((plan) => JSON.stringify(plan))
-    };
-}
 export function makeLogMachine(wire, core) {
     const cancel = (operation, callback) => wire.runtimeCancel(operation, callback);
     const commandEntries = new WeakMap();
+    const historyEntries = new WeakMap();
     function makeCommand(cw) {
         const state = { closed: false };
         const command = {
@@ -346,22 +305,19 @@ export function makeLogMachine(wire, core) {
                 return {
                     kind: "decided",
                     receipt: receiptOf(outcome.receipt),
-                    localHealth: healthOf(operation, outcome.localHealth),
-                    phase: phaseOf(operation, outcome.publicationPhase)
+                    localHealth: healthOf(operation, outcome.localHealth)
                 };
             case "not-submitted":
                 return {
                     kind: "not-submitted",
                     command: ref,
-                    error: errorOf(operation, outcome.error),
-                    phase: phaseOf(operation, outcome.publicationPhase)
+                    error: errorOf(operation, outcome.error)
                 };
             case "outcome-unknown":
                 return {
                     kind: "outcome-unknown",
                     command: ref,
-                    error: errorOf(operation, outcome.error),
-                    phase: phaseOf(operation, outcome.publicationPhase)
+                    error: errorOf(operation, outcome.error)
                 };
         }
     }
@@ -430,8 +386,7 @@ export function makeLogMachine(wire, core) {
                         return Effect.succeed({
                             kind: "not-submitted",
                             command: ref,
-                            error: closedHandle(operation),
-                            phase: "prepared"
+                            error: closedHandle(operation)
                         });
                     }
                     return certaintyOperation(operation, cancel, (callback) => wire.logHistoryCall(capability, {
@@ -443,13 +398,11 @@ export function makeLogMachine(wire, core) {
                     }, callback), wire.logHistoryResult, (result) => decodeSubmit(operation, ref, result), (error) => ({
                         kind: "not-submitted",
                         command: ref,
-                        error,
-                        phase: "prepared"
+                        error
                     }), (error) => ({
                         kind: "outcome-unknown",
                         command: ref,
-                        error,
-                        phase: "dispatchedUnresolved"
+                        error
                     }));
                 });
             },
@@ -480,24 +433,28 @@ export function makeLogMachine(wire, core) {
     function makeHistory(schema, handle) {
         const state = { closed: false };
         const members = makeFacadeMembers(schema, handle.history, handle.meta, state);
-        return {
+        const history = {
             ...members,
             close: () => Effect.suspend(() => {
                 state.closed = true;
                 return drainClose("History.close", (callback) => wire.logHistoryClose(handle.history, callback));
             })
         };
+        historyEntries.set(history, { capability: handle.history, schema });
+        return history;
     }
     function makeBorrow(schema, handle) {
         const state = { closed: false };
         const members = makeFacadeMembers(schema, handle.history, handle.meta, state);
-        return {
+        const history = {
             ...members,
             release: () => Effect.suspend(() => {
                 state.closed = true;
                 return drainClose("HistoryBorrow.release", (callback) => wire.logBorrowRelease(handle.history, callback));
             })
         };
+        historyEntries.set(history, { capability: handle.history, schema });
+        return history;
     }
     function openHistory(operation, kind, mode, binding, schema, options) {
         return Effect.gen(function* () {
@@ -534,15 +491,12 @@ export function makeLogMachine(wire, core) {
             const acquire = Effect.suspend(() => {
                 // The exact core registry accessor: a foreign dynamic object
                 // refuses before any native dispatch (the Db.apply pattern);
-                // a spent/closed ChangeSet refuses as ClosedHandle; a scope/
-                // change schema mismatch refuses before native work.
+                // a scope/change schema mismatch refuses before native work.
+                // Native admission owns the ChangeSet's lifetime.
                 const internal = core.changes(input.changes);
                 if (internal === undefined) {
                     return Effect.fail(invalidInput(operation));
                 }
-                if (internal.closed) {
-                    return Effect.fail(closedHandle(operation));
-                }
                 let request;
                 try {
                     if (String(internal.schemaId) !== String(input.scope.schemaId)) {
@@ -600,12 +554,6 @@ export function makeLogMachine(wire, core) {
                     try {
                         request = {
                             maxOpen: checkedCount(operation, options.maxOpen, 0xffffffff),
-                            expected: options.expected === undefined
-                                ? null
-                                : {
-                                    schemaId: checkedString(operation, options.expected.schemaId, 64),
-                                    appliedPrefixDigest: checkedString(operation, options.expected.appliedPrefixDigest, 64)
-                                },
                             schema: core.schemaSpec(schema)
                         };
                     }
@@ -676,22 +624,19 @@ export function makeLogMachine(wire, core) {
                 return {
                     kind: "completed",
                     ref,
-                    value: decode(result.value),
-                    phase: phaseOf(operation, result.publicationPhase)
+                    value: decode(result.value)
                 };
             case "not-started":
                 return {
                     kind: "not-started",
                     ref,
-                    error: errorOf(operation, result.error),
-                    phase: phaseOf(operation, result.publicationPhase)
+                    error: errorOf(operation, result.error)
                 };
             case "outcome-unknown":
                 return {
                     kind: "outcome-unknown",
                     ref,
-                    error: errorOf(operation, result.error),
-                    phase: phaseOf(operation, result.publicationPhase)
+                    error: errorOf(operation, result.error)
                 };
             case "report":
                 // A read-only certainty from a mutating verb is a wire defect.
@@ -705,18 +650,16 @@ export function makeLogMachine(wire, core) {
                 return {
                     kind: "not-started",
                     ref,
-                    error: runtime.failure,
-                    phase: "prepared"
+                    error: runtime.failure
                 };
             }
             // `ref` is the caller-supplied operationId, fixed before dispatch.
             // Interrupt after the native lease is outcome-unknown under this
             // same ref; retry status/the same operationId, never a new mint.
-            return yield* certaintyOperation(operation, cancel, (callback) => wire.logAdmin(runtime.success, request(), callback), wire.logAdminTake, (result) => decodeAdmin(operation, ref, result, decode), (error) => ({ kind: "not-started", ref, error, phase: "prepared" }), (error) => ({
+            return yield* certaintyOperation(operation, cancel, (callback) => wire.logAdmin(runtime.success, request(), callback), wire.logAdminTake, (result) => decodeAdmin(operation, ref, result, decode), (error) => ({ kind: "not-started", ref, error }), (error) => ({
                 kind: "outcome-unknown",
                 ref,
-                error,
-                phase: "dispatchedUnresolved"
+                error
             }));
         });
     }
@@ -742,13 +685,6 @@ export function makeLogMachine(wire, core) {
     function backupField(operation, backup) {
         return backup === undefined ? {} : { backup: checkedUuid(operation, backup) };
     }
-    /** Optional source binding + target schema for activate/abort. */
-    function targetFields(operation, options) {
-        return {
-            ...(options.binding === undefined ? {} : { binding: bindingWire(operation, options.binding) }),
-            ...schemaField(options.schema)
-        };
-    }
     function destinationWire(operation, destination) {
         if (destination.kind === "filesystem") {
             return { kind: "filesystem", directory: checkedString(operation, destination.directory, 4096) };
@@ -772,104 +708,6 @@ export function makeLogMachine(wire, core) {
             return value;
         };
     }
-    function sourceAccessOf(wire) {
-        return {
-            access: wire.access,
-            operation: wire.operationId === null ? null : wire.operationId
-        };
-    }
-    // `ActivationRef` is declared in #migrations/types.ts:
-    // { operation: OperationId, planSetDigest, target, targetGenesis }.
-    function activationRefOf(wire) {
-        return {
-            operation: wire.operationId,
-            planSetDigest: wire.planSetDigest,
-            target: identityOf(wire.target),
-            targetGenesis: wire.targetGenesis
-        };
-    }
-    function migrationRefOf(wire) {
-        return {
-            operation: { identity: identityOf(wire.identity), operation: wire.operationId },
-            planSetDigest: wire.planSetDigest,
-            target: identityOf(wire.target)
-        };
-    }
-    function activationRefWire(operation, ref) {
-        return {
-            operationId: checkedUuid(operation, ref.operation),
-            planSetDigest: checkedString(operation, ref.planSetDigest, 64),
-            target: identityWire(operation, ref.target),
-            targetGenesis: checkedString(operation, ref.targetGenesis, 64)
-        };
-    }
-    function migrationRefWire(operation, ref) {
-        return {
-            identity: identityWire(operation, ref.operation.identity),
-            operationId: checkedUuid(operation, ref.operation.operation),
-            planSetDigest: checkedString(operation, ref.planSetDigest, 64),
-            target: identityWire(operation, ref.target)
-        };
-    }
-    function migrateValueOf(operation, wire) {
-        switch (wire.kind) {
-            case "up-to-date":
-                return { kind: "up-to-date", binding: bindingOf(wire.binding) };
-            case "ready-to-switch":
-                return {
-                    kind: "ready-to-switch",
-                    deploymentBinding: bindingOf(wire.deploymentBinding),
-                    activation: activationRefOf(wire.activation)
-                };
-            case "paused":
-                return {
-                    kind: "paused",
-                    error: errorOf(operation, wire.error),
-                    sourceState: sourceAccessOf(wire.sourceState)
-                };
-        }
-    }
-    function migrationStatusOf(operation, wire) {
-        switch (wire.kind) {
-            case "up-to-date":
-                return { kind: "up-to-date", appliedPrefixDigest: wire.appliedPrefixDigest };
-            case "pending":
-                return { kind: "pending", pending: wire.pending };
-            case "in-progress":
-                return { kind: "in-progress", operation: migrationRefOf(wire.operationRef).operation };
-            case "paused":
-                return {
-                    kind: "paused",
-                    operation: migrationRefOf(wire.operationRef).operation,
-                    error: errorOf(operation, wire.error),
-                    sourceState: sourceAccessOf(wire.sourceState)
-                };
-            case "ready-to-switch":
-                return {
-                    kind: "ready-to-switch",
-                    operation: migrationRefOf(wire.operationRef).operation,
-                    activation: activationRefOf(wire.activation)
-                };
-            case "activated":
-                return {
-                    kind: "activated",
-                    operation: migrationRefOf(wire.operationRef).operation,
-                    target: identityOf(wire.target)
-                };
-            case "aborted":
-                return { kind: "aborted", operation: migrationRefOf(wire.operationRef).operation };
-            case "outcome-unknown":
-                return {
-                    kind: "outcome-unknown",
-                    operation: migrationRefOf(wire.operationRef).operation,
-                    error: errorOf(operation, wire.error)
-                };
-            case "drift":
-                return { kind: "drift", detail: wire.detail };
-            case "database-ahead":
-                return { kind: "database-ahead", detail: wire.detail };
-        }
-    }
     const admin = {
         checkpoint(binding, options) {
             const operation = "admin.checkpoint";
@@ -1038,75 +876,174 @@ export function makeLogMachine(wire, core) {
             });
         }
     };
-    const migrations = {
-        migrationStatus(binding, plans, options) {
-            const operation = "migrations.status";
-            return adminQuery(operation, () => ({
-                verb: "migration-status",
-                binding: bindingWire(operation, binding),
-                ...schemaField(options.schema),
-                plans: plansWire(operation, plans)
-            }), (value) => {
-                const report = expectVerb(operation, "migration-status")(value);
-                return migrationStatusOf(operation, report.status);
+    function contractWire(operation, contract) {
+        return {
+            operationId: checkedUuid(operation, contract.operation),
+            source: identityWire(operation, contract.source),
+            target: identityWire(operation, contract.target),
+            commitment: checkedString(operation, contract.commitment, 64)
+        };
+    }
+    function contractOf(contract) {
+        return {
+            operation: contract.operationId,
+            source: identityOf(contract.source),
+            target: identityOf(contract.target),
+            commitment: contract.commitment
+        };
+    }
+    function captureOf(captured) {
+        return {
+            contract: contractOf(captured.contract),
+            decision: stampOf(captured.decision),
+            state: stateOf(captured.state)
+        };
+    }
+    function installedOf(installed) {
+        return {
+            captured: captureOf(installed.captured),
+            applicationDigest: installed.applicationDigest,
+            bytes: installed.bytes
+        };
+    }
+    function readyOf(result) {
+        return {
+            kind: "ready",
+            installed: installedOf(result.installed),
+            binding: {
+                kind: "local",
+                directory: result.directory,
+                identity: identityOf(result.installed.captured.contract.target)
+            }
+        };
+    }
+    function resolutionOf(operation, result) {
+        switch (result.kind) {
+            case "ready":
+                return readyOf(result);
+            case "activated":
+                return {
+                    kind: "activated",
+                    contract: contractOf(result.contract),
+                    genesis: result.genesis,
+                    binding: { kind: "local", directory: result.directory, identity: identityOf(result.contract.target) }
+                };
+            case "uninstalled":
+                return { kind: "uninstalled" };
+            case "aborted":
+                return { kind: "aborted" };
+            default:
+                throw invalidInput(operation);
+        }
+    }
+    function transitionCall(operation, history, request, accept) {
+        return Effect.suspend(() => {
+            const entry = historyEntries.get(history);
+            if (entry === undefined)
+                return Effect.fail(invalidInput(operation));
+            let input;
+            try {
+                input = request();
+            }
+            catch (cause) {
+                return Effect.fail(logFailure(operation, cause));
+            }
+            return logOperation(operation, cancel, (callback) => wire.logTransitionCall(entry.capability, input, callback), wire.logTransitionResult, accept);
+        });
+    }
+    function makePopulation(schema, handle) {
+        return {
+            schema,
+            apply(changes) {
+                const operation = "Population.apply";
+                return Effect.suspend(() => {
+                    const entry = core.changes(changes);
+                    if (entry === undefined)
+                        return Effect.fail(invalidInput(operation));
+                    return logOperation(operation, cancel, (callback) => wire.logPopulationApply(handle, entry.handle, callback), wire.logTransitionResult, (result) => {
+                        if (result.kind !== "applied")
+                            throw invalidInput(operation);
+                    });
+                });
+            },
+            finish() {
+                const operation = "Population.finish";
+                return logOperation(operation, cancel, (callback) => wire.logPopulationFinish(handle, callback), wire.logTransitionResult, (result) => {
+                    if (result.kind !== "ready")
+                        throw invalidInput(operation);
+                    return readyOf(result);
+                });
+            },
+            close: () => drainClose("Population.close", (callback) => wire.logPopulationClose(handle, callback))
+        };
+    }
+    const TransitionNamespace = {
+        begin(source, target, contract) {
+            const operation = "Transition.begin";
+            const acquire = transitionCall(operation, source, () => ({ verb: "begin", contract: contractWire(operation, contract), schema: core.schemaSpec(target) }), (result) => {
+                if (result.kind === "activated")
+                    return resolutionOf(operation, result);
+                if (result.kind === "aborted")
+                    return { kind: "aborted" };
+                if (result.kind !== "ready" && result.kind !== "populating")
+                    throw invalidInput(operation);
+                const entry = historyEntries.get(source);
+                if (entry === undefined || result.source === undefined)
+                    throw invalidInput(operation);
+                const reader = makeSnapshot(entry.schema, result.source.snapshot, result.source.provenance);
+                if (result.kind === "ready")
+                    return { ...readyOf(result), source: reader };
+                return {
+                    kind: "populating",
+                    captured: captureOf(result.captured),
+                    source: reader,
+                    population: makePopulation(target, result.population),
+                    binding: {
+                        kind: "local",
+                        directory: result.directory,
+                        identity: identityOf(result.captured.contract.target)
+                    }
+                };
             });
+            return scopedResource(operation, acquire, (value) => Effect.gen(function* () {
+                if (value.kind === "populating") {
+                    const population = yield* value.population.close();
+                    const source = yield* value.source.close();
+                    return population.kind === "closed" ? source : population;
+                }
+                if (value.kind === "ready")
+                    return yield* value.source.close();
+                return { kind: "closed" };
+            }));
         },
-        initialize(binding, plans, options) {
-            const operation = "migrations.initialize";
-            return adminMutation(operation, operationRef(binding, options.operationId), () => ({
-                verb: "migration-initialize",
-                binding: bindingWire(operation, binding),
-                ...schemaField(options.schema),
-                operationId: checkedUuid(operation, options.operationId),
-                plans: plansWire(operation, plans)
-            }), (value) => {
-                const report = expectVerb(operation, "migration-initialize")(value);
-                return { binding: bindingOf(report.binding), genesis: report.genesis };
-            });
+        resolve(source, target, contract) {
+            const operation = "Transition.resolve";
+            return transitionCall(operation, source, () => ({ verb: "resolve", contract: contractWire(operation, contract), schema: core.schemaSpec(target) }), (result) => resolutionOf(operation, result));
         },
-        migrate(binding, plans, options) {
-            const operation = "migrations.migrate";
-            return adminMutation(operation, operationRef(binding, options.operationId), () => ({
-                verb: "migration-migrate",
-                binding: bindingWire(operation, binding),
-                ...schemaField(options.schema),
-                operationId: checkedUuid(operation, options.operationId),
-                plans: plansWire(operation, plans),
-                to: options.to === undefined ? null : checkedString(operation, options.to, 256)
-            }), (value) => {
-                const report = expectVerb(operation, "migration-migrate")(value);
-                return migrateValueOf(operation, report.value);
+        inspect(target, installed) {
+            const operation = "Transition.inspect";
+            const acquire = transitionCall(operation, target, () => ({ verb: "inspect", evidence: installed.bytes }), (result) => {
+                const entry = historyEntries.get(target);
+                if (entry === undefined || result.kind !== "ready" || result.source === undefined)
+                    throw invalidInput(operation);
+                return makeSnapshot(entry.schema, result.source.snapshot, result.source.provenance);
             });
+            return scopedResource(operation, acquire, (reader) => reader.close());
         },
-        activateMigration(ref, options) {
-            const operation = "migrations.activate";
-            return adminMutation(operation, { identity: ref.target, operation: ref.operation }, () => ({
-                verb: "migration-activate",
-                ref: activationRefWire(operation, ref),
-                ...targetFields(operation, options)
-            }), (value) => {
-                const report = expectVerb(operation, "migration-activate")(value);
-                return {
-                    target: identityOf(report.target),
-                    accessMode: report.accessMode,
-                    operation: report.operationId,
-                    activatedNow: report.activatedNow
-                };
+        activate(source, target, installed) {
+            const operation = "Transition.activate";
+            return transitionCall(operation, source, () => ({ verb: "activate", evidence: installed.bytes, schema: core.schemaSpec(target) }), (result) => {
+                const value = resolutionOf(operation, result);
+                if (value.kind !== "activated")
+                    throw invalidInput(operation);
+                return value;
             });
         },
-        abortMigration(ref, options) {
-            const operation = "migrations.abort";
-            return adminMutation(operation, ref.operation, () => ({
-                verb: "migration-abort",
-                ref: migrationRefWire(operation, ref),
-                ...targetFields(operation, options)
-            }), (value) => {
-                const report = expectVerb(operation, "migration-abort")(value);
-                return {
-                    target: identityOf(report.target),
-                    targetFenced: report.targetFenced,
-                    sourceAccess: report.sourceAccess
-                };
+        abort(source, target, contract) {
+            const operation = "Transition.abort";
+            return transitionCall(operation, source, () => ({ verb: "abort", contract: contractWire(operation, contract), schema: core.schemaSpec(target) }), (result) => {
+                if (result.kind !== "aborted")
+                    throw invalidInput(operation);
             });
         }
     };
@@ -1116,7 +1053,7 @@ export function makeLogMachine(wire, core) {
         Command: CommandNamespace,
         TenantCache: TenantCacheNamespace,
         admin,
-        migrations
+        Transition: TransitionNamespace
     };
 }
 //# sourceMappingURL=machine.js.map