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

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import type { CollectionContractDescriptor, CollectionDescription, CollectionTypeDescriptor, JsonObject, RecordDocument } from "@mdbase-dev/connect-protocol";
-import { type ConnectRequestOptions, type MdbaseConnection, type PendingMutation } 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";

package/dist/index.js

@@ -1,5 +1,4 @@
-import { MDBASE_RECORD_CREATED_CONTRACT } from "@mdbase-dev/connect-protocol";
-import { ConnectOutcomeError, 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
@@ -48,31 +47,31 @@ export class PickleCollection {
         this.connect = connect;
     }
     async describe(options = {}) {
-        this.description ??= unwrapConnectOutcome(await this.connect.describe(options));
+        this.description ??= requireOutcome(await this.connect.describe(options));
         this.contract ??= resolvePickleContract(this.description);
         return { collection: this.description, contract: this.contract };
     }
     async list(options = {}) {
         const { collection, contract } = await this.describe(options);
-        const requestQuery = unwrapConnectOutcome(await this.connect.queryAll({
+        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"
+                includeBody: true,
+                frontmatterMode: "effective"
             }, options))).results.map(requireEffectiveFrontmatter)
             : [];
         return requests
@@ -133,13 +132,13 @@ function responseSubmission(outcome) {
         : null;
     if (requestId)
         return { kind: "pending", requestId };
-    throw new ConnectOutcomeError(outcome.problem);
+    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
@@ -149,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",
@@ -188,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.32",
+  "version": "0.1.0-beta.34",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -22,13 +22,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@mdbase-dev/connect-protocol": "0.1.0-beta.32",
-    "@mdbase-dev/connect": "0.1.0-beta.32"
+    "@mdbase-dev/connect": "0.1.0-beta.34"
   },
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
-    "@mdbase-dev/connect-dev": "0.1.0-beta.32"
+    "@mdbase-dev/connect-dev": "0.1.0-beta.34",
+    "@mdbase-dev/connect-testing": "0.1.0-beta.34"
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",