@anweather/game-plugin-ssdk 1.8.0 → 1.10.0

package/dist-es/runtime/blobClient.js

@@ -0,0 +1,74 @@
+export const blobOwner = {
+    save: (saveFileId) => `save:${saveFileId}`,
+    player: (participantId) => `player:${participantId}`,
+    world: (worldId) => `world:${worldId}`,
+};
+export class BlobStoreError extends Error {
+    type;
+    status;
+    details;
+    constructor(type, status, details) {
+        super(`${type}: ${String(details.message ?? status)}`);
+        this.type = type;
+        this.status = status;
+        this.details = details;
+        this.name = "BlobStoreError";
+    }
+}
+export function isVersionConflict(e) {
+    return e instanceof BlobStoreError && e.type === "VersionConflict";
+}
+const ERROR_TYPES = new Set([
+    "VersionConflict", "BlobTooLarge", "BlobQuotaExceeded", "BlobOwnerNotFound", "InvalidBlobRequest", "PluginUnauthorized",
+]);
+export function createBlobClient(options) {
+    const doFetch = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? 5000;
+    const root = `${options.platformUrl}/internal/plugins/${encodeURIComponent(options.gameType)}/blobs`;
+    async function call(method, path, body) {
+        const headers = {};
+        if (options.authToken)
+            headers["X-Plugin-Auth"] = `Bearer ${options.authToken}`;
+        if (body !== undefined)
+            headers["Content-Type"] = "application/json";
+        const res = await doFetch(`${root}/${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const text = await res.text();
+        const parsed = text ? JSON.parse(text) : {};
+        if (res.ok)
+            return parsed;
+        const type = (res.headers.get("X-Amzn-Errortype") ?? parsed.__type ?? "");
+        if (ERROR_TYPES.has(type))
+            throw new BlobStoreError(type, res.status, parsed);
+        throw new Error(`blob store ${method} ${path}: ${res.status} ${text.slice(0, 200)}`);
+    }
+    const at = (owner, key) => key === undefined ? encodeURIComponent(owner) : `${encodeURIComponent(owner)}/${encodeURIComponent(key)}`;
+    return {
+        get: (owner, key) => call("GET", at(owner, key)),
+        put: (owner, key, value, expectedVersion) => call("PUT", at(owner, key), { value, expectedVersion }),
+        delete: (owner, key, expectedVersion) => call("DELETE", at(owner, key) + (expectedVersion === undefined ? "" : `?expectedVersion=${expectedVersion}`)),
+        batchGet: async (owner, keys) => (await call("POST", `${at(owner)}/batch-get`, { keys })).items,
+        batchPut: async (owner, writes) => (await call("POST", `${at(owner)}/batch-put`, { writes })).items,
+        list: (owner) => call("GET", at(owner)),
+    };
+}
+export async function casUpdate(client, owner, key, change, maxAttempts = 5) {
+    for (let attempt = 1;; attempt++) {
+        const current = await client.get(owner, key);
+        const next = change(current.version === 0 ? undefined : current.value);
+        if (next === undefined)
+            return { value: current.value, version: current.version };
+        try {
+            const { version } = await client.put(owner, key, next, current.version);
+            return { value: next, version };
+        }
+        catch (e) {
+            if (!isVersionConflict(e) || attempt >= maxAttempts)
+                throw e;
+        }
+    }
+}

package/dist-es/runtime/index.js

@@ -4,3 +4,4 @@ export { servePlugin, createPluginApp } from "./servePlugin";
 export { createRegistrationLoop } from "./registration";
 export { runConformance, assertConformance } from "./conformance";
 export { PLUGIN_PROTOCOL_VERSION, runtimeVersion } from "./version";
+export { createBlobClient, casUpdate, blobOwner, BlobStoreError, isVersionConflict } from "./blobClient";

package/dist-es/src/models/models_0.js

@@ -108,6 +108,14 @@ export var PluginStateUpdate;
                         memberValidators["awaitingParticipantIds"] = new __CompositeCollectionValidator(new __NoOpValidator(), new __NoOpValidator());
                         break;
                     }
+                    case "undoDisabled": {
+                        memberValidators["undoDisabled"] = new __NoOpValidator();
+                        break;
+                    }
+                    case "undoBarrier": {
+                        memberValidators["undoBarrier"] = new __NoOpValidator();
+                        break;
+                    }
                 }
             }
             return memberValidators[member];
@@ -117,6 +125,8 @@ export var PluginStateUpdate;
             ...getMemberValidator("pluginState").validate(obj.pluginState, `${path}/pluginState`),
             ...getMemberValidator("loggedPayload").validate(obj.loggedPayload, `${path}/loggedPayload`),
             ...getMemberValidator("awaitingParticipantIds").validate(obj.awaitingParticipantIds, `${path}/awaitingParticipantIds`),
+            ...getMemberValidator("undoDisabled").validate(obj.undoDisabled, `${path}/undoDisabled`),
+            ...getMemberValidator("undoBarrier").validate(obj.undoBarrier, `${path}/undoBarrier`),
         ];
     };
 })(PluginStateUpdate || (PluginStateUpdate = {}));

package/dist-es/src/protocols/Aws_restJson1.js

@@ -428,6 +428,8 @@ export const serializeApplyMoveResponse = async (input, ctx) => {
         'loggedPayload': _ => se_Document(_, context),
         'nextTurnParticipantId': [],
         'pluginState': _ => se_Document(_, context),
+        'undoBarrier': [],
+        'undoDisabled': [],
     }));
     if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
         const length = calculateBodyLength(body);
@@ -740,6 +742,8 @@ export const serializeInitializeGameResponse = async (input, ctx) => {
         'loggedPayload': _ => se_Document(_, context),
         'nextTurnParticipantId': [],
         'pluginState': _ => se_Document(_, context),
+        'undoBarrier': [],
+        'undoDisabled': [],
     }));
     if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
         const length = calculateBodyLength(body);