@arcadible/sdk 1.5.2-next.0 → 1.5.3-next.6

package/dist/values/server.js

@@ -0,0 +1,71 @@
+// The page's side of `values`: a game's call to its values, passed to
+// wherever the page asks (`call`), which is its own server. The page holds
+// no rule: who may read and write which scope, the limits, and who's
+// playing are its server's to say. The page says only what it must: that
+// the call came from the game it serves.
+// [import]
+import { ArcadibleError, Codes, isObject, log, MAX_MESSAGE, messageSize, } from "../bus/protocol.js";
+import { Names } from "./rules.js";
+// The codes a page's `call` may refuse with; anything else is
+// `unavailable`.
+const REFUSALS = new Set([
+    Codes.Busy,
+    Codes.Conflict,
+    Codes.Denied,
+    Codes.Full,
+    Codes.Invalid,
+    Codes.TooLarge,
+    Codes.TooMany,
+    Codes.Unavailable,
+]);
+const MESSAGES = {
+    [Codes.Busy]: "Too many calls. Wait a moment, and try again.",
+    [Codes.Conflict]: "The value was written since the revision named. Read it again.",
+    [Codes.Denied]: "A game reads the developer's and the game's values, and reads and writes its own player's, who's logged in.",
+    [Codes.Full]: "The player's storage is used up. Remove something first.",
+    [Codes.Invalid]: "Arcadible didn't take the call.",
+    [Codes.TooLarge]: "A value, or the call's values together, is too large.",
+    [Codes.TooMany]: "A call names up to 32 keys.",
+};
+const UNAVAILABLE = "The game's values can't be reached right now. Try again.";
+// [function]
+export function valuesServer(host) {
+    const run = function (verb) {
+        return async function (params) {
+            const body = params["body"];
+            if (typeof body !== "string") {
+                throw new ArcadibleError(Codes.Invalid, MESSAGES[Codes.Invalid] ?? "");
+            }
+            try {
+                const text = await host.call(verb, body);
+                if (typeof text !== "string")
+                    throw new TypeError("not text");
+                // a read is held to what fits a message where it's kept; an answer
+                // that outgrew one on the way is said, not dropped
+                if (messageSize({ text }, MAX_MESSAGE) > MAX_MESSAGE - 1024) {
+                    throw new ArcadibleError(Codes.TooLarge, "The values are too large to read together. Read fewer at once.");
+                }
+                return { text };
+            }
+            catch (err) {
+                if (err instanceof ArcadibleError)
+                    throw err;
+                const refused = isObject(err) ? err["code"] : undefined;
+                if (typeof refused === "string" && REFUSALS.has(refused)) {
+                    throw new ArcadibleError(refused, MESSAGES[refused] ?? UNAVAILABLE);
+                }
+                log("warn", "the game's values couldn't be reached.", err);
+                throw new ArcadibleError(Codes.Unavailable, UNAVAILABLE);
+            }
+        };
+    };
+    return () => ({
+        handlers: {
+            // beside the queue: each waits on the network, not on storage.
+            [Names.List]: { run: run("list"), parallel: true },
+            [Names.Read]: { run: run("read"), parallel: true },
+            [Names.Remove]: { run: run("remove"), parallel: true },
+            [Names.Write]: { run: run("write"), parallel: true },
+        },
+    });
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.5.2-next.0";
+export declare const VERSION = "1.5.3-next.6";

package/dist/version.js

@@ -1,3 +1,3 @@
 // The client's version, sent in its hello and shown as `arcadible.version`,
 // for bug reports. It matches package.json (test/unit/protocol.test.ts).
-export const VERSION = "1.5.2-next.0";
+export const VERSION = "1.5.3-next.6";

package/package.json

@@ -43,5 +43,5 @@
   ],
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.5.2-next.0"
+  "version": "1.5.3-next.6"
 }