@mfxhub/sdk 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -6,6 +6,28 @@ Every release of `@mfxhub/sdk`, newest first. The format follows
 
 ## Unreleased
 
+## 0.1.2
+
+### Fixed
+
+- An order sent again with the same idempotency key, after the first had already finished, came
+  back with `ok` false and no price, tickets or broker comment, because the platform answers a
+  repeat with the command's state only. A filled order read as not filled. The SDK now reads the
+  command once and returns the original result in full, marked `duplicate`. A repeat still in
+  flight is returned as it is, with no extra read.
+- If that read fails, `placeOrder` still resolves with what the platform said (the state, `ok`
+  true for a success, `duplicate`) with the price and tickets empty, and `detail` names the
+  `getCommand` call that reads the rest. It never rejects.
+
+### Added
+
+- `execution.getCommand(commandId)`: one command and its result, as the platform has it now. Like
+  every execution method it resolves to an `ExecutionResult` and never rejects.
+
+### Changed
+
+- The SDK passes the shared SDK test suite 0.3.0, all 74 cases.
+
 ## 0.1.1
 
 No change to what the SDK does: the same API and behaviour as 0.1.0, and all 72 cases of the

package/README.md

@@ -62,7 +62,7 @@ logged in to.
 | Signing   | every request and the stream's upgrade, Ed25519                                       |
 | Errors    | one typed error per error code the API names                                          |
 | Terminals | `get`, `page`, `list`, `create`                                                       |
-| Execution | `placeOrder`, with `ExecutionResult` for every outcome                                |
+| Execution | `placeOrder` and `getCommand`, with `ExecutionResult` for every outcome               |
 | Catalogue | `quote`                                                                               |
 | Stream    | `client.stream()`: events, results, account, ticks, candles, book and expert channels |
 

package/dist/execution.d.ts

@@ -44,5 +44,13 @@ export declare class Execution {
      * belongs, a missing idempotency key, a comment over 31 characters.
      */
     placeOrder(terminalId: string, order: PlaceOrder): Promise<ExecutionResult>;
+    /**
+     * One command and its result, as the platform has it now. A command of another tenant is not
+     * found, never forbidden. Like every method here it resolves to a result and never rejects:
+     * a caller checking what happened to an order must not have to catch to learn it cannot tell.
+     *
+     * `idempotencyKey` is only carried into the result, so a retry can reuse it; a read sends none.
+     */
+    getCommand(commandId: string, idempotencyKey?: string): Promise<ExecutionResult>;
 }
 export {};

package/dist/execution.js

@@ -76,8 +76,19 @@ export class Execution {
         const body = orderBody(order);
         return this.#command({ method: "POST", path: `/terminals/${id}/orders`, body, idempotencyKey: key }, key);
     }
+    /**
+     * One command and its result, as the platform has it now. A command of another tenant is not
+     * found, never forbidden. Like every method here it resolves to a result and never rejects:
+     * a caller checking what happened to an order must not have to catch to learn it cannot tell.
+     *
+     * `idempotencyKey` is only carried into the result, so a retry can reuse it; a read sends none.
+     */
+    async getCommand(commandId, idempotencyKey = "") {
+        const id = uuid("commandId", commandId);
+        return this.#command({ method: "GET", path: `/commands/${id}` }, idempotencyKey, false);
+    }
     /** Sends one execution call, once, and turns everything it can do into a result. */
-    async #command(spec, key) {
+    async #command(spec, key, write = true) {
         const started = performance.now();
         const elapsed = () => performance.now() - started;
         const what = `${spec.method} ${spec.path}`;
@@ -114,6 +125,23 @@ export class Execution {
             // throwFor throws only the API's typed errors: every other answer is a refusal.
             return concluded("refused", key, elapsed(), `${what}: ${error.message}`);
         }
-        return fromCommand(answer.body, key, elapsed());
+        const result = fromCommand(answer.body, key, elapsed());
+        if (!(write && result.duplicate && result.final && result.commandId !== null))
+            return result;
+        // A repeat of a command that is already final is answered with its state only: read the
+        // command once, so the caller gets the original result - price, tickets, reason - and not an
+        // empty one. One extra read, only on a final repeat.
+        const original = await this.getCommand(result.commandId, key);
+        if (original.commandId !== null && original.state !== null) {
+            return { ...original, duplicate: true, clientRttMs: elapsed() };
+        }
+        // DECISION: the read failed. Report what the platform did say - the state, ok
+        // from it, duplicate - and how to read the rest. Never UNKNOWN: the outcome is known.
+        return {
+            ...result,
+            clientRttMs: elapsed(),
+            detail: `the original result could not be read (${original.detail ?? "no answer"}); ` +
+                `execution.getCommand('${result.commandId}') reads it`,
+        };
     }
 }

package/dist/index.d.ts

@@ -23,4 +23,4 @@ export { RequestSigner, SigningKey, signingMessage } from "./signing.js";
 export { KEY_HEADER, NONCE_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER } from "./signing.js";
 export type { components, operations, paths } from "./generated/api.js";
 /** This package's version. */
-export declare const VERSION = "0.1.1";
+export declare const VERSION = "0.1.2";

package/dist/index.js

@@ -16,4 +16,4 @@ export { Terminals, isUsable } from "./terminals.js";
 export { RequestSigner, SigningKey, signingMessage } from "./signing.js";
 export { KEY_HEADER, NONCE_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER } from "./signing.js";
 /** This package's version. */
-export const VERSION = "0.1.1";
+export const VERSION = "0.1.2";

package/dist/results.js

@@ -60,10 +60,13 @@ export function fromCommand(body, idempotencyKey, clientRttMs) {
     const raw = record(body);
     const state = typeof raw.state === "string" && STATES.has(raw.state) ? raw.state : null;
     const result = record(raw.result);
+    const hasResult = result === raw.result; // record() returns the object itself only for an object
     const reasonText = text(result.reason);
     const tickets = record(result.tickets);
     return {
-        ok: result.ok === true,
+        // The result says, once there is one. A CommandAccepted has none: a repeat of a command that
+        // already succeeded says so by its state alone.
+        ok: hasResult ? result.ok === true : state === "SUCCEEDED",
         idempotencyKey,
         clientRttMs,
         commandId: text(raw.command_id),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mfxhub/sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Typed TypeScript client for the MFX Hub API: hosted trading terminals, market data, execution and a live event stream",
   "license": "Apache-2.0",
   "type": "module",