@mdbase-dev/pickle 0.1.0-beta.31 → 0.1.0-beta.32

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { CollectionContractDescriptor, CollectionDescription, CollectionTypeDescriptor, JsonObject, RecordDocument } from "@mdbase-dev/connect-protocol";
-import { type MdbaseConnection } from "@mdbase-dev/connect";
+import { type ConnectRequestOptions, type MdbaseConnection, type PendingMutation } from "@mdbase-dev/connect";
 export { PICKLE_ACK_RESPONSE_TYPE_DOCUMENT, PICKLE_APPROVAL_RESPONSE_TYPE_DOCUMENT, PICKLE_REQUEST_CONTRACT_DOCUMENT, PICKLE_REQUEST_CONTRACT_DIGEST, PICKLE_TYPE_PACK_PROVISION, PICKLE_REQUEST_TYPE_DOCUMENT } from "./resources.js";
 export declare const PICKLE_REQUEST_CONTRACT = "pickle.request";
 export declare const PICKLE_REQUEST_CONTRACT_VERSION = "1.0.0";
@@ -78,13 +78,23 @@ export interface PickleRequest {
     response?: PickleResponse;
     frontmatter: PickleFrontmatter;
 }
-export interface RespondOptions {
+export interface RespondOptions extends ConnectRequestOptions {
     responder?: string;
 }
+export type PickleResponseSubmission = {
+    kind: "recorded";
+    record: RecordDocument<PickleFrontmatter>;
+} | {
+    kind: "pending";
+    requestId: string;
+};
+export type PicklePendingResponse = PendingMutation<RecordDocument<PickleFrontmatter>>;
 export interface PickleClient {
-    describe(): ReturnType<MdbaseConnection<PickleFrontmatter>["describe"]>;
-    queryAll(input: Parameters<MdbaseConnection<PickleFrontmatter>["queryAll"]>[0]): ReturnType<MdbaseConnection<PickleFrontmatter>["queryAll"]>;
-    create(input: Parameters<MdbaseConnection<PickleFrontmatter>["create"]>[0]): ReturnType<MdbaseConnection<PickleFrontmatter>["create"]>;
+    describe(options?: ConnectRequestOptions): ReturnType<MdbaseConnection<PickleFrontmatter>["describe"]>;
+    queryAll(input: Parameters<MdbaseConnection<PickleFrontmatter>["queryAll"]>[0], options?: Parameters<MdbaseConnection<PickleFrontmatter>["queryAll"]>[1]): ReturnType<MdbaseConnection<PickleFrontmatter>["queryAll"]>;
+    create(input: Parameters<MdbaseConnection<PickleFrontmatter>["create"]>[0], options?: ConnectRequestOptions): ReturnType<MdbaseConnection<PickleFrontmatter>["create"]>;
+    pendingMutations<Result = unknown>(): readonly PendingMutation<Result>[];
+    pendingMutation<Result = unknown>(requestId: string): PendingMutation<Result> | null;
 }
 export declare function resolvePickleContract(description: CollectionDescription): PickleContract;
 export declare class PickleCollection {
@@ -96,8 +106,14 @@ export declare class PickleCollection {
         collection: CollectionDescription;
         contract: PickleContract;
     }>;
-    list(): Promise<PickleRequest[]>;
-    respond(request: PickleRequest, payload: JsonObject, options?: RespondOptions): Promise<RecordDocument<PickleFrontmatter>>;
+    describe(options: ConnectRequestOptions): Promise<{
+        collection: CollectionDescription;
+        contract: PickleContract;
+    }>;
+    list(options?: ConnectRequestOptions): Promise<PickleRequest[]>;
+    respond(request: PickleRequest, payload: JsonObject, options?: RespondOptions): Promise<PickleResponseSubmission>;
+    pendingResponses(): readonly PicklePendingResponse[];
+    recoverResponse(requestId: string, options?: ConnectRequestOptions): Promise<PickleResponseSubmission>;
 }
 export declare class PickleContractError extends Error {
 }

package/dist/index.js

@@ -1,5 +1,5 @@
 import { MDBASE_RECORD_CREATED_CONTRACT } from "@mdbase-dev/connect-protocol";
-import { unwrapConnectOutcome } from "@mdbase-dev/connect";
+import { ConnectOutcomeError, unwrapConnectOutcome } from "@mdbase-dev/connect";
 import { PICKLE_REQUEST_CONTRACT_DIGEST } from "./resources.js";
 export { PICKLE_ACK_RESPONSE_TYPE_DOCUMENT, PICKLE_APPROVAL_RESPONSE_TYPE_DOCUMENT, PICKLE_REQUEST_CONTRACT_DOCUMENT, PICKLE_REQUEST_CONTRACT_DIGEST, PICKLE_TYPE_PACK_PROVISION, PICKLE_REQUEST_TYPE_DOCUMENT } from "./resources.js";
 export const PICKLE_REQUEST_CONTRACT = "pickle.request";
@@ -47,18 +47,18 @@ export class PickleCollection {
     constructor(connect) {
         this.connect = connect;
     }
-    async describe() {
-        this.description ??= unwrapConnectOutcome(await this.connect.describe());
+    async describe(options = {}) {
+        this.description ??= unwrapConnectOutcome(await this.connect.describe(options));
         this.contract ??= resolvePickleContract(this.description);
         return { collection: this.description, contract: this.contract };
     }
-    async list() {
-        const { collection, contract } = await this.describe();
+    async list(options = {}) {
+        const { collection, contract } = await this.describe(options);
         const requestQuery = unwrapConnectOutcome(await this.connect.queryAll({
             types: contract.implementations.map(({ typeName }) => typeName),
             include_body: true,
             frontmatter_mode: "effective"
-        }));
+        }, options));
         const requests = requestQuery.results.map(requireEffectiveFrontmatter);
         const responseTypes = [
             ...new Set(requests
@@ -73,7 +73,7 @@ export class PickleCollection {
                 types: responseTypes,
                 include_body: true,
                 frontmatter_mode: "effective"
-            }))).results.map(requireEffectiveFrontmatter)
+            }, options))).results.map(requireEffectiveFrontmatter)
             : [];
         return requests
             .map((record) => normalizeRequest(record, responses, collection, contract))
@@ -91,23 +91,50 @@ export class PickleCollection {
         }
         const responseFolder = stringField(asObject(responseType.collection?.path), "folder") ||
             "responses";
+        const { responder, ...requestOptions } = options;
         const frontmatter = {
             ...payload,
             type: request.responseType,
             request: requestLink(request.path),
-            responder: options.responder?.trim() || "human"
+            responder: responder?.trim() || "human"
         };
         const created = await this.connect.create({
             type: request.responseType,
             path: `${trimSlashes(responseFolder)}/${crypto.randomUUID()}.md`,
             frontmatter,
             body: ""
-        });
-        return unwrapConnectOutcome(created);
+        }, requestOptions);
+        return responseSubmission(created);
+    }
+    pendingResponses() {
+        return this.connect
+            .pendingMutations()
+            .filter((mutation) => mutation.operation === "create");
+    }
+    async recoverResponse(requestId, options = {}) {
+        const pending = this.connect.pendingMutation(requestId);
+        if (!pending || pending.operation !== "create") {
+            throw new PickleContractError("This pending Pickle response is no longer available for recovery.");
+        }
+        return responseSubmission(await pending.recover(options));
     }
 }
 export class PickleContractError extends Error {
 }
+function responseSubmission(outcome) {
+    if (outcome.ok)
+        return { kind: "recorded", record: outcome.value };
+    const requestId = outcome.problem.code === "operation_outcome_unknown" &&
+        outcome.problem.details &&
+        typeof outcome.problem.details === "object" &&
+        "request_id" in outcome.problem.details &&
+        typeof outcome.problem.details.request_id === "string"
+        ? outcome.problem.details.request_id
+        : null;
+    if (requestId)
+        return { kind: "pending", requestId };
+    throw new ConnectOutcomeError(outcome.problem);
+}
 function normalizeRequest(record, responseRecords, description, contract) {
     const implementation = implementationForRecord(contract, record);
     const responseType = stringField(record.effective_frontmatter, role(implementation, "response_type", "response_type")) || "pickle_response_approval";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdbase-dev/pickle",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.32",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -22,13 +22,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@mdbase-dev/connect": "0.1.0-beta.31",
-    "@mdbase-dev/connect-protocol": "0.1.0-beta.31"
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.32",
+    "@mdbase-dev/connect": "0.1.0-beta.32"
   },
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
-    "@mdbase-dev/connect-dev": "0.1.0-beta.31"
+    "@mdbase-dev/connect-dev": "0.1.0-beta.32"
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",