@effect-agent/storage-memory 0.1.0-beta.36 → 0.1.0-beta.38

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { ConversationStore, SubmissionLedger } from "@effect-agent/session";
+import { ConversationStore, ScheduleStore, SubmissionLedger } from "@effect-agent/session";
 import { Crypto, Effect, Layer, Option } from "effect";
 //#region src/memory-ledger.d.ts
 /** Construction options for the in-memory reference SubmissionLedger. */
@@ -18,6 +18,10 @@ interface MemorySubmissionLedgerOptions {
 declare const memorySubmissionLedgerLayer: (options?: MemorySubmissionLedgerOptions) => Layer.Layer<SubmissionLedger>;
 declare const MemorySubmissionLedgerLive: Layer.Layer<SubmissionLedger>;
 //#endregion
+//#region src/memory-schedule-store.d.ts
+declare const memoryScheduleStoreLayer: () => Layer.Layer<ScheduleStore>;
+declare const MemoryScheduleStoreLive: Layer.Layer<ScheduleStore>;
+//#endregion
 //#region src/memory-storage.d.ts
 declare const MemoryConversationStoreLive: Layer.Layer<ConversationStore, never, Crypto.Crypto>;
 /**
@@ -26,5 +30,5 @@ declare const MemoryConversationStoreLive: Layer.Layer<ConversationStore, never,
  */
 declare const MemoryStorageLive: Layer.Layer<ConversationStore, never, Crypto.Crypto>;
 //#endregion
-export { MemoryConversationStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemorySubmissionLedgerOptions, memorySubmissionLedgerLayer };
+export { MemoryConversationStoreLive, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemorySubmissionLedgerOptions, memoryScheduleStoreLayer, memorySubmissionLedgerLayer };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { AttemptId, ConversationId, ReceiptId, SubmissionId } from "@effect-agent/core";
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SuspendRequest, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch, settlementFailureFromRecord } from "@effect-agent/session";
-import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Schema, Stream } from "effect";
+import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SuspendRequest, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, compareScheduleKeys, compareScheduleNames, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity, settlementFailureFromRecord } from "@effect-agent/session";
+import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
 //#region src/memory-ledger.ts
 const MAX_SUBMISSIONS = 65536;
 /**
@@ -992,6 +992,164 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 const memorySubmissionLedgerLayer = (options = {}) => Layer.effect(SubmissionLedger, makeSubmissionLedger(options));
 const MemorySubmissionLedgerLive = memorySubmissionLedgerLayer();
 //#endregion
+//#region src/memory-schedule-store.ts
+const storageError = (operation, reason) => ScheduleStorageError.make({
+	operation,
+	reason
+});
+const encodeRecord = (operation, record) => Effect.try({
+	try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(record),
+	catch: () => storageError(operation, "corrupt")
+});
+const decodeRecord = (operation, encoded) => Effect.try({
+	try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(encoded),
+	catch: () => storageError(operation, "corrupt")
+});
+const decodeInput = (operation, schema, value) => Effect.try({
+	try: () => Schema.decodeUnknownSync(schema)(value),
+	catch: () => storageError(operation, "corrupt")
+});
+const sameOwner = (record, owner) => scheduleOwnerKey(record.owner) === scheduleOwnerKey(owner);
+const makeScheduleStore = Effect.gen(function* () {
+	const state = yield* Ref.make({ records: /* @__PURE__ */ new Map() });
+	const failpoint = yield* ScheduleFailpoint;
+	const insert = Effect.fn("MemoryScheduleStore.insert")((record, ownerLimit) => Effect.gen(function* () {
+		const encoded = yield* encodeRecord("insert", record);
+		yield* failpoint.hit("schedule:insert:before");
+		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const key = scheduleKeyString(record);
+			const existingText = current.records.get(key);
+			if (existingText !== void 0) {
+				const decoded = Result.try({
+					try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(existingText),
+					catch: () => storageError("insert", "corrupt")
+				});
+				if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
+				if (decoded.success.creationFingerprint === record.creationFingerprint) return [Result.succeed(decoded.success), current];
+				return [Result.fail(ScheduleConflict.make({
+					reason: "creation",
+					key: scheduleKeyOf(record)
+				})), current];
+			}
+			let ownerCount = 0;
+			for (const text of current.records.values()) {
+				const decoded = Result.try({
+					try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
+					catch: () => storageError("insert", "corrupt")
+				});
+				if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
+				if (sameOwner(decoded.success, record.owner) && scheduleUsesCapacity(decoded.success)) ownerCount += 1;
+			}
+			if (ownerCount >= ownerLimit) return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
+			const records = new Map(current.records);
+			records.set(key, encoded);
+			const next = { records };
+			return [Result.succeed(record), next];
+		}));
+		const inserted = yield* Effect.fromResult(decision);
+		yield* failpoint.hit("schedule:insert:after");
+		return yield* decodeRecord("insert", yield* encodeRecord("insert", inserted));
+	}));
+	const get = Effect.fn("MemoryScheduleStore.get")(function* (key) {
+		const decodedKey = yield* decodeInput("get", ScheduleKey, key);
+		const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));
+		return text === void 0 ? null : yield* decodeRecord("get", text);
+	});
+	const list = Effect.fn("MemoryScheduleStore.list")(function* (request) {
+		const decodedRequest = yield* decodeInput("list", SchedulePageRequest, request);
+		const records = [];
+		for (const text of (yield* Ref.get(state)).records.values()) {
+			const record = yield* decodeRecord("list", text);
+			if (sameOwner(record, decodedRequest.owner) && (decodedRequest.after === void 0 || compareScheduleNames(record.scheduleId, decodedRequest.after) > 0)) records.push(record);
+		}
+		records.sort((left, right) => compareScheduleNames(left.scheduleId, right.scheduleId));
+		const hasNext = records.length > decodedRequest.limit;
+		const items = records.slice(0, decodedRequest.limit);
+		return {
+			items,
+			next: hasNext ? items.at(-1)?.scheduleId ?? null : null
+		};
+	});
+	const change = Effect.fn("MemoryScheduleStore.change")((key, command, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) => Effect.gen(function* () {
+		const decodedKey = yield* decodeInput("change", ScheduleKey, key);
+		const decodedCommand = yield* decodeInput("change", ScheduleChange, command);
+		yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:before`);
+		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const storageKey = scheduleKeyString(decodedKey);
+			const text = current.records.get(storageKey);
+			if (text === void 0) return [Result.fail(ScheduleNotFound.make({ key: decodedKey })), current];
+			const decoded = Result.try({
+				try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
+				catch: () => storageError("change", "corrupt")
+			});
+			if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
+			const applied = applyScheduleChange(decoded.success, decodedCommand);
+			if (Result.isFailure(applied)) return [Result.fail(applied.failure), current];
+			if (applied.success === decoded.success) return [Result.succeed(decoded.success), current];
+			if (!scheduleUsesCapacity(decoded.success) && scheduleUsesCapacity(applied.success)) {
+				let count = 0;
+				for (const text of current.records.values()) {
+					const candidate = Schema.decodeUnknownResult(Schema.fromJsonString(ScheduleRecord))(text);
+					if (Result.isFailure(candidate)) return [Result.fail(storageError("change", "corrupt")), current];
+					if (sameOwner(candidate.success, decodedKey.owner) && scheduleUsesCapacity(candidate.success)) count += 1;
+				}
+				if (count >= ownerLimit) return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
+			}
+			const encoded = Result.try({
+				try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),
+				catch: () => storageError("change", "corrupt")
+			});
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const records = new Map(current.records);
+			records.set(storageKey, encoded.success);
+			const next = { records };
+			return [Result.succeed(applied.success), next];
+		}));
+		const changed = yield* Effect.fromResult(decision);
+		yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);
+		return yield* decodeRecord("change", yield* encodeRecord("change", changed));
+	}));
+	const due = Effect.fn("MemoryScheduleStore.due")(function* (nowMillis, limit, owner, after) {
+		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput("due", ScheduleOwner, owner);
+		const cursor = after === void 0 ? void 0 : yield* decodeInput("due", ScheduleDueCursor, after);
+		const records = [];
+		for (const text of (yield* Ref.get(state)).records.values()) {
+			const record = yield* decodeRecord("due", text);
+			const deadline = scheduleDeadline(record);
+			if (deadline !== null && deadline <= nowMillis && (decodedOwner === void 0 || sameOwner(record, decodedOwner)) && (cursor === void 0 || deadline > cursor.deadlineAtMillis || deadline === cursor.deadlineAtMillis && compareScheduleKeys(record, cursor) > 0)) records.push({
+				...scheduleKeyOf(record),
+				deadlineAtMillis: deadline
+			});
+		}
+		records.sort((left, right) => {
+			const byDeadline = left.deadlineAtMillis - right.deadlineAtMillis;
+			return byDeadline !== 0 ? byDeadline : compareScheduleKeys(left, right);
+		});
+		return records.slice(0, limit);
+	});
+	const nextDeadline = Effect.fn("MemoryScheduleStore.nextDeadline")(function* (owner) {
+		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
+		let earliest = null;
+		for (const text of (yield* Ref.get(state)).records.values()) {
+			const record = yield* decodeRecord("nextDeadline", text);
+			if (decodedOwner !== void 0 && !sameOwner(record, decodedOwner)) continue;
+			const deadline = scheduleDeadline(record);
+			if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
+		}
+		return earliest;
+	});
+	return ScheduleStore.of({
+		insert,
+		get,
+		list,
+		change,
+		due,
+		nextDeadline
+	});
+});
+const memoryScheduleStoreLayer = () => Layer.effect(ScheduleStore, makeScheduleStore);
+const MemoryScheduleStoreLive = memoryScheduleStoreLayer();
+//#endregion
 //#region src/memory-storage.ts
 const MAX_CONVERSATIONS = 256;
 const MAX_RECORDS_PER_CONVERSATION = 65536;
@@ -1292,6 +1450,6 @@ const MemoryConversationStoreLive = Layer.effect(ConversationStore, makeConversa
 */
 const MemoryStorageLive = MemoryConversationStoreLive;
 //#endregion
-export { MemoryConversationStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, memorySubmissionLedgerLayer };
+export { MemoryConversationStoreLive, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, memoryScheduleStoreLayer, memorySubmissionLedgerLayer };
 
 //# sourceMappingURL=index.mjs.map