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

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import type { CollectionContractDescriptor, CollectionDescription, CollectionTypeDescriptor, JsonObject, RecordDocument } from "@mdbase-dev/connect-protocol";
-import { type MdbaseConnection } from "@mdbase-dev/connect";
+import { type CollectionContractDescriptor, type CollectionDescription, type CollectionTypeDescriptor, type JsonObject, type RecordDocument, 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 +77,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 +105,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,4 @@
-import { MDBASE_RECORD_CREATED_CONTRACT } from "@mdbase-dev/connect-protocol";
-import { unwrapConnectOutcome } from "@mdbase-dev/connect";
+import { MDBASE_RECORD_CREATED_CONTRACT, MdbaseConnectError } 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";
@@ -23,11 +22,11 @@ export function resolvePickleContract(description) {
         throw new PickleContractError("This collection does not provide the Pickle request contract.");
     }
     const implementations = descriptor.implementations.map((implementation) => {
-        const requestType = description.types.find((candidate) => candidate.name === implementation.type_name);
+        const requestType = description.types.find((candidate) => candidate.name === implementation.typeName);
         if (!requestType)
-            throw new PickleContractError(`The Pickle request type ${implementation.type_name} is missing from this collection.`);
+            throw new PickleContractError(`The Pickle request type ${implementation.typeName} is missing from this collection.`);
         return {
-            typeName: implementation.type_name,
+            typeName: implementation.typeName,
             fields: parseFields(implementation.fields),
             binding: implementation.binding,
             requestType
@@ -47,33 +46,33 @@ export class PickleCollection {
     constructor(connect) {
         this.connect = connect;
     }
-    async describe() {
-        this.description ??= unwrapConnectOutcome(await this.connect.describe());
+    async describe(options = {}) {
+        this.description ??= requireOutcome(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();
-        const requestQuery = unwrapConnectOutcome(await this.connect.queryAll({
+    async list(options = {}) {
+        const { collection, contract } = await this.describe(options);
+        const requestQuery = requireOutcome(await this.connect.queryAll({
             types: contract.implementations.map(({ typeName }) => typeName),
-            include_body: true,
-            frontmatter_mode: "effective"
-        }));
+            includeBody: true,
+            frontmatterMode: "effective"
+        }, options));
         const requests = requestQuery.results.map(requireEffectiveFrontmatter);
         const responseTypes = [
             ...new Set(requests
                 .map((record) => {
                 const implementation = implementationForRecord(contract, record);
-                return stringField(record.effective_frontmatter, role(implementation, "response_type", "response_type"));
+                return stringField(record.effectiveFrontmatter, role(implementation, "response_type", "response_type"));
             })
                 .filter(Boolean))
         ];
         const responses = responseTypes.length
-            ? (unwrapConnectOutcome(await this.connect.queryAll({
+            ? (requireOutcome(await this.connect.queryAll({
                 types: responseTypes,
-                include_body: true,
-                frontmatter_mode: "effective"
-            }))).results.map(requireEffectiveFrontmatter)
+                includeBody: true,
+                frontmatterMode: "effective"
+            }, options))).results.map(requireEffectiveFrontmatter)
             : [];
         return requests
             .map((record) => normalizeRequest(record, responses, collection, contract))
@@ -91,28 +90,55 @@ 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 MdbaseConnectError(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";
-    const linked = responseRecords.filter((candidate) => linkTargets(candidate.effective_frontmatter.request, record.path));
-    const status = stringField(record.effective_frontmatter, role(implementation, "status", "status"));
+    const responseType = stringField(record.effectiveFrontmatter, role(implementation, "response_type", "response_type")) || "pickle_response_approval";
+    const linked = responseRecords.filter((candidate) => linkTargets(candidate.effectiveFrontmatter.request, record.path));
+    const status = stringField(record.effectiveFrontmatter, role(implementation, "status", "status"));
     const state = status === "cancelled"
         ? "cancelled"
         : linked.length === 0
@@ -122,35 +148,35 @@ function normalizeRequest(record, responseRecords, description, contract) {
                 : "conflict";
     const response = linked.length === 1 ? normalizeResponse(linked[0]) : undefined;
     return {
-        id: stringField(record.effective_frontmatter, role(implementation, "id", "id")) ||
+        id: stringField(record.effectiveFrontmatter, role(implementation, "id", "id")) ||
             record.path,
         path: record.path,
-        title: stringField(record.effective_frontmatter, role(implementation, "title", "title")) ||
+        title: stringField(record.effectiveFrontmatter, role(implementation, "title", "title")) ||
             record.path,
-        source: stringField(record.effective_frontmatter, role(implementation, "source", "source")) ||
+        source: stringField(record.effectiveFrontmatter, role(implementation, "source", "source")) ||
             "agent",
-        message: stringField(record.effective_frontmatter, role(implementation, "message", "message")),
+        message: stringField(record.effectiveFrontmatter, role(implementation, "message", "message")),
         body: record.body ?? "",
-        kind: stringField(record.effective_frontmatter, role(implementation, "kind", "kind")) ||
+        kind: stringField(record.effectiveFrontmatter, role(implementation, "kind", "kind")) ||
             "approval",
-        priority: stringField(record.effective_frontmatter, role(implementation, "priority", "priority")) || "normal",
+        priority: stringField(record.effectiveFrontmatter, role(implementation, "priority", "priority")) || "normal",
         status: status || undefined,
         state,
         responseCount: linked.length,
         responseType,
         responseTypeDefinition: description.types.find((candidate) => candidate.name === responseType),
-        createdAt: stringField(record.effective_frontmatter, role(implementation, "created_at", "created_at")) || undefined,
-        dueAt: stringField(record.effective_frontmatter, "due_at") || undefined,
-        tags: stringList(getField(record.effective_frontmatter, role(implementation, "tags", "tags"))),
-        links: links(getField(record.effective_frontmatter, role(implementation, "links", "links"))),
-        attachments: attachments(getField(record.effective_frontmatter, role(implementation, "attachment_paths", "attachment_paths"))),
-        metadata: asObject(getField(record.effective_frontmatter, role(implementation, "metadata", "metadata"))) ?? {},
+        createdAt: stringField(record.effectiveFrontmatter, role(implementation, "created_at", "created_at")) || undefined,
+        dueAt: stringField(record.effectiveFrontmatter, "due_at") || undefined,
+        tags: stringList(getField(record.effectiveFrontmatter, role(implementation, "tags", "tags"))),
+        links: links(getField(record.effectiveFrontmatter, role(implementation, "links", "links"))),
+        attachments: attachments(getField(record.effectiveFrontmatter, role(implementation, "attachment_paths", "attachment_paths"))),
+        metadata: asObject(getField(record.effectiveFrontmatter, role(implementation, "metadata", "metadata"))) ?? {},
         response,
-        frontmatter: record.effective_frontmatter
+        frontmatter: record.effectiveFrontmatter
     };
 }
 function normalizeResponse(record) {
-    const frontmatter = record.effective_frontmatter;
+    const frontmatter = record.effectiveFrontmatter;
     return {
         path: record.path,
         type: stringField(frontmatter, "type") || record.types[0] || "pickle_response",
@@ -161,11 +187,16 @@ function normalizeResponse(record) {
     };
 }
 function requireEffectiveFrontmatter(record) {
-    if (!record.effective_frontmatter) {
-        throw new PickleContractError(`Query result ${record.path} omitted effective_frontmatter.`);
+    if (!record.effectiveFrontmatter) {
+        throw new PickleContractError(`Query result ${record.path} omitted effectiveFrontmatter.`);
     }
     return record;
 }
+function requireOutcome(outcome) {
+    if (!outcome.ok)
+        throw new MdbaseConnectError(outcome.problem);
+    return outcome.value;
+}
 function parseFields(value) {
     if (!Object.values(value).every((field) => typeof field === "string" && validFieldPath(field)))
         throw new PickleContractError("The Pickle request contract is malformed.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdbase-dev/pickle",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.33",
   "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": "0.1.0-beta.33"
   },
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
-    "@mdbase-dev/connect-dev": "0.1.0-beta.31"
+    "@mdbase-dev/connect-testing": "0.1.0-beta.33",
+    "@mdbase-dev/connect-dev": "0.1.0-beta.33"
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",