@hipnation-truth/sdk 0.10.0 → 0.12.0

package/dist/index.mjs

@@ -168,6 +168,65 @@ var AttachmentsResource = class {
       }
     });
   }
+  /**
+   * One-shot upload: presign → PUT to S3 → record in Convex → return a
+   * 7-day signed download URL ready to embed in an outbound SMS. Caller
+   * passes the resulting `downloadUrl` to `messages.dialpad.sendSms` (or
+   * the new `messages.sendAttachmentMessage`) to actually deliver it.
+   *
+   * Replaces CommHub's NestJS `/send-attachment` controller in a single
+   * SDK call — no base64 round-trip, no legacy `/attachments/:id/download`
+   * REST endpoint required.
+   */
+  upload(input) {
+    return __async(this, null, function* () {
+      var _a;
+      const presigned = yield this.createUploadUrl({
+        fileName: input.fileName,
+        mimeType: input.mimeType,
+        size: input.size,
+        conversationId: input.conversationId
+      });
+      const body = input.file instanceof Blob ? input.file : input.file instanceof Uint8Array ? input.file : new Uint8Array(input.file);
+      const abort = new AbortController();
+      const timer = setTimeout(() => abort.abort(), 3e4);
+      let putRes;
+      try {
+        putRes = yield fetch(presigned.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": input.mimeType },
+          body,
+          signal: abort.signal
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!putRes.ok) {
+        throw new AttachmentsError(
+          "s3-put",
+          putRes.status,
+          `S3 PUT ${putRes.status} for ${presigned.s3Key}`
+        );
+      }
+      const recorded = yield this.record({
+        s3Key: presigned.s3Key,
+        fileName: input.fileName,
+        mimeType: input.mimeType,
+        size: input.size,
+        conversationId: input.conversationId,
+        uploadedBy: input.uploadedBy
+      });
+      const signed = yield this.getDownloadUrl(
+        presigned.s3Key,
+        (_a = input.downloadExpiresIn) != null ? _a : 7 * 24 * 3600
+      );
+      return {
+        attachmentId: recorded.attachmentId,
+        s3Key: presigned.s3Key,
+        downloadUrl: signed.url
+      };
+    });
+  }
 };
 
 // src/resources/dialpad.ts
@@ -398,6 +457,36 @@ var DialpadResource = class {
 var MessagesResource = class {
   constructor(apiBaseUrl, apiKey) {
     this.dialpad = new DialpadResource(apiBaseUrl, apiKey);
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * End a Dialpad call via the typed oRPC procedure (POST hangup, with
+   * 404→`alreadyEnded` so the UI doesn't flash an error on a natural
+   * race). Replaces CommHub's `useEndCallMutation` Hasura action.
+   *
+   * Prefer this over `messages.dialpad.endCall` which goes through the
+   * generic proxy (PUT, no 404 handling).
+   */
+  endCall(callId) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api/conversations/calls/end`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({ callId })
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new Error(
+          `messages.endCall failed (HTTP ${res.status}): ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    });
   }
 };
 var DialpadProxyError = class extends Error {
@@ -547,30 +636,77 @@ var NotesError = class extends Error {
     this.status = status;
   }
 };
-var NotesResource = class {
+var _NotesResource = class _NotesResource {
   constructor(apiBaseUrl, apiKey) {
     this.baseUrl = apiBaseUrl;
     this.apiKey = apiKey;
   }
-  pushToElation(input) {
+  post(path, body) {
     return __async(this, null, function* () {
-      const res = yield fetch(`${this.baseUrl}/api/notes/push-to-elation`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          "X-API-Key": this.apiKey
-        },
-        body: JSON.stringify(input)
-      });
+      const controller = new AbortController();
+      const timeout = setTimeout(
+        () => controller.abort(),
+        _NotesResource.REQUEST_TIMEOUT_MS
+      );
+      let res;
+      try {
+        res = yield fetch(`${this.baseUrl}/api${path}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "X-API-Key": this.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+      } catch (err) {
+        const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+        const message = isAbort ? `Notes ${path} timed out after ${_NotesResource.REQUEST_TIMEOUT_MS}ms` : err instanceof Error ? err.message : "Notes request failed before response";
+        throw new NotesError(path, 0, message);
+      } finally {
+        clearTimeout(timeout);
+      }
       if (!res.ok) {
         const text = yield res.text().catch(() => "");
-        throw new NotesError("pushToElation", res.status, text.slice(0, 200));
+        throw new NotesError(path, res.status, text.slice(0, 200));
       }
       return yield res.json();
     });
   }
+  /**
+   * Low-level — caller has already resolved Elation patient / physician
+   * / practice. Use `pushConversationToElation` if you only have a
+   * conversation handle.
+   */
+  pushToElation(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/notes/push-to-elation",
+        input
+      );
+    });
+  }
+  /**
+   * Orchestrator — pass a conversation handle + pre-assembled note text.
+   * Truth resolves the linked patient via Convex, looks up
+   * physician/practice in Elation, posts the note, and writes an audit
+   * row to `elationSyncEvents`. Replaces CommHub's `pushNotesToElation`
+   * Hasura action.
+   */
+  pushConversationToElation(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/notes/push-conversation-to-elation",
+        input
+      );
+    });
+  }
 };
+/** 30s upstream timeout — Elation API has occasional slow hops; we
+ *  don't want a pending mutation to hold the UI thread indefinitely. */
+_NotesResource.REQUEST_TIMEOUT_MS = 3e4;
+var NotesResource = _NotesResource;
 
 // src/resources/notifications.ts
 var NotificationsError = class extends Error {