@anweather/game-plugin-ssdk 1.17.0 → 1.19.0

package/dist-es/runtime/blobClient.js

@@ -2,6 +2,7 @@ export const blobOwner = {
     save: (saveFileId) => `save:${saveFileId}`,
     player: (participantId) => `player:${participantId}`,
     world: (worldId) => `world:${worldId}`,
+    space: (spaceId) => `space:${spaceId}`,
 };
 export class BlobStoreError extends Error {
     type;
@@ -24,7 +25,7 @@ const ERROR_TYPES = new Set([
 export function createBlobClient(options) {
     const doFetch = options.fetchImpl ?? fetch;
     const timeoutMs = options.timeoutMs ?? 5000;
-    const root = `${options.platformUrl}/internal/plugins/${encodeURIComponent(options.gameType)}/blobs`;
+    const root = `${options.platformUrl}/internal/plugins/${encodeURIComponent(options.gameType)}`;
     async function call(method, path, body) {
         const headers = {};
         if (options.authToken)
@@ -46,7 +47,7 @@ export function createBlobClient(options) {
             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)}`;
+    const at = (owner, key) => key === undefined ? `blobs/${encodeURIComponent(owner)}` : `blobs/${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 }),
@@ -54,8 +55,24 @@ export function createBlobClient(options) {
         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)),
+        listOwners: (prefix = "", page = {}) => {
+            const query = new URLSearchParams({ prefix });
+            if (page.after !== undefined)
+                query.set("after", page.after);
+            if (page.limit !== undefined)
+                query.set("limit", String(page.limit));
+            return call("GET", `blob-owners?${query}`);
+        },
     };
 }
+export async function* allBlobOwners(client, prefix = "", pageSize) {
+    let after;
+    do {
+        const page = await client.listOwners(prefix, { after, limit: pageSize });
+        yield* page.owners;
+        after = page.nextToken;
+    } while (after !== undefined);
+}
 export async function casUpdate(client, owner, key, change, maxAttempts = 5) {
     for (let attempt = 1;; attempt++) {
         const current = await client.get(owner, key);

package/dist-es/runtime/index.js

@@ -4,9 +4,10 @@ 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";
+export { createBlobClient, casUpdate, blobOwner, allBlobOwners, BlobStoreError, isVersionConflict } from "./blobClient";
 export { attachLive } from "./live/server";
 export { createLiveHarness } from "./live/harness";
 export { loadRoomCheckpoint } from "./live/checkpoint";
 export { runLiveConformance, assertLiveConformance } from "./live/conformance";
 export { LIVE_PROTOCOL_VERSION, LIVE_PATH, LinkCloseCode, MAX_LINK_FRAME_BYTES } from "./live/protocol";
+export { createSpaceClient, createMembershipGuard, isAlreadyASpace, SpaceApiError, NotASpaceMemberError, FakeSpaceClient, MAX_MEMBERSHIP_AGE_MS, } from "./spaceClient";

package/dist-es/runtime/spaceClient.js

@@ -0,0 +1,205 @@
+export class SpaceApiError 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 = "SpaceApiError";
+    }
+}
+export function isAlreadyASpace(e) {
+    return e instanceof SpaceApiError && e.type === "SpaceAlreadyExists";
+}
+const ERROR_TYPES = new Set([
+    "SpaceNotFound", "InvalidSpaceImport", "SpaceImportDisabled", "SpaceAlreadyExists", "InviteCodeTaken", "PluginUnauthorized",
+]);
+export function createSpaceClient(options) {
+    const doFetch = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? 5000;
+    const base = `${options.platformUrl}/internal/plugins/${encodeURIComponent(options.gameType)}`;
+    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(`${base}/${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const text = await res.text();
+        let parsed = {};
+        try {
+            parsed = text ? JSON.parse(text) : {};
+        }
+        catch {
+        }
+        if (res.ok)
+            return parsed;
+        const type = (res.headers.get("X-Amzn-Errortype") ?? parsed.__type ?? "");
+        if (ERROR_TYPES.has(type))
+            throw new SpaceApiError(type, res.status, parsed);
+        throw new Error(`spaces ${method} ${path}: ${res.status} ${text.slice(0, 200)}`);
+    }
+    return {
+        get: async (spaceId) => {
+            try {
+                return await call("GET", `spaces/${encodeURIComponent(spaceId)}`);
+            }
+            catch (e) {
+                if (e instanceof SpaceApiError && e.type === "SpaceNotFound")
+                    return null;
+                throw e;
+            }
+        },
+        import: (spaceId, body) => call("PUT", `spaces/${encodeURIComponent(spaceId)}/import`, body),
+        counts: () => call("GET", "space-counts"),
+    };
+}
+export const MAX_MEMBERSHIP_AGE_MS = 15_000;
+export class NotASpaceMemberError extends Error {
+    spaceId;
+    playerId;
+    constructor(spaceId, playerId) {
+        super(`${playerId} is not an ACTIVE member of Space ${spaceId}`);
+        this.spaceId = spaceId;
+        this.playerId = playerId;
+        this.name = "NotASpaceMemberError";
+    }
+}
+export function createMembershipGuard(client, options = {}) {
+    const maxAgeMs = Math.min(options.maxAgeMs ?? MAX_MEMBERSHIP_AGE_MS, MAX_MEMBERSHIP_AGE_MS);
+    const now = options.now ?? Date.now;
+    const cache = new Map();
+    function space(spaceId) {
+        const t = now();
+        const cached = cache.get(spaceId);
+        if (cached && t - cached.at < maxAgeMs)
+            return cached.read;
+        for (const [id, entry] of cache)
+            if (t - entry.at >= maxAgeMs)
+                cache.delete(id);
+        const read = client.get(spaceId);
+        cache.set(spaceId, { at: t, read });
+        const forget = () => {
+            if (cache.get(spaceId)?.read === read)
+                cache.delete(spaceId);
+        };
+        read.then((s) => { if (s === null)
+            forget(); }, forget);
+        return read;
+    }
+    const isMember = (s, playerId) => s !== null && s.members.some((m) => m.playerId === playerId && m.status === "ACTIVE");
+    return {
+        space,
+        isActiveMember: async (spaceId, playerId) => isMember(await space(spaceId), playerId),
+        assertActiveMember: async (spaceId, playerId) => {
+            const s = await space(spaceId);
+            if (!isMember(s, playerId))
+                throw new NotASpaceMemberError(spaceId, playerId);
+            return s;
+        },
+        invalidate: (spaceId) => (spaceId === undefined ? cache.clear() : void cache.delete(spaceId)),
+    };
+}
+export class FakeSpaceClient {
+    options;
+    spaces = new Map();
+    calls = [];
+    names = new Map();
+    importEnabled = true;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    add(space) {
+        const at = new Date(0).toISOString();
+        this.spaces.set(space.id, {
+            space: { id: space.id, name: space.name ?? "Space", ownerId: space.ownerId, settings: space.settings ?? {}, archived: false, revision: 1 },
+            inviteCode: space.inviteCode ? normalizeCode(space.inviteCode) : null,
+            members: new Map([[space.ownerId, { playerId: space.ownerId, role: "OWNER", status: "ACTIVE", joinedAt: at, statusAt: at }]]),
+        });
+    }
+    setStatus(spaceId, playerId, status) {
+        const s = this.spaces.get(spaceId);
+        if (!s)
+            throw new Error(`no Space ${spaceId}`);
+        const at = new Date().toISOString();
+        const current = s.members.get(playerId);
+        s.members.set(playerId, current ? { ...current, status, statusAt: at } : { playerId, role: "MEMBER", status, joinedAt: at, statusAt: at });
+        s.space.revision++;
+        s.imported = undefined;
+    }
+    archive(spaceId) {
+        const s = this.spaces.get(spaceId);
+        if (!s)
+            throw new Error(`no Space ${spaceId}`);
+        s.space.archived = true;
+        s.space.revision++;
+        s.imported = undefined;
+    }
+    async get(spaceId) {
+        this.calls.push(`get ${spaceId}`);
+        const s = this.spaces.get(spaceId);
+        return s ? this.view(s) : null;
+    }
+    async import(spaceId, body) {
+        this.calls.push(`import ${spaceId}`);
+        const refuse = (type, status, details = {}) => {
+            throw new SpaceApiError(type, status, { message: type, ...details });
+        };
+        if (!this.importEnabled)
+            refuse("SpaceImportDisabled", 403);
+        const owners = body.members.filter((m) => m.role === "OWNER");
+        if (owners.length !== 1 || owners[0].playerId !== body.ownerId || owners[0].status !== "ACTIVE") {
+            refuse("InvalidSpaceImport", 400, { message: "exactly one ACTIVE OWNER, who is ownerId" });
+        }
+        const code = body.inviteCode ? normalizeCode(body.inviteCode) : null;
+        const key = JSON.stringify({ ...body, inviteCode: code, settings: body.settings ?? {} });
+        const existing = this.spaces.get(spaceId);
+        if (existing) {
+            if (existing.imported === key)
+                return { created: false, space: this.view(existing) };
+            refuse("SpaceAlreadyExists", 409);
+        }
+        if (this.options.players) {
+            const known = new Set(this.options.players);
+            const unknown = [...new Set([body.ownerId, ...body.members.map((m) => m.playerId)])].filter((p) => !known.has(p));
+            if (unknown.length > 0)
+                refuse("InvalidSpaceImport", 400, { unknownPlayerIds: unknown });
+        }
+        if (code && [...this.spaces.values()].some((s) => s.inviteCode === code))
+            refuse("InviteCodeTaken", 409);
+        const stored = {
+            space: { id: spaceId, name: body.name.trim(), ownerId: body.ownerId, settings: body.settings ?? {}, archived: false, revision: 1 },
+            inviteCode: code,
+            members: new Map(body.members.map((m) => [m.playerId, { ...m }])),
+            imported: key,
+        };
+        this.spaces.set(spaceId, stored);
+        return { created: true, space: this.view(stored) };
+    }
+    async counts() {
+        this.calls.push("counts");
+        const all = [...this.spaces.values()];
+        return {
+            spaces: all.length,
+            inviteCodes: all.filter((s) => s.inviteCode !== null).length,
+            activeMembers: all.reduce((n, s) => n + [...s.members.values()].filter((m) => m.status === "ACTIVE").length, 0),
+        };
+    }
+    view(s) {
+        const members = [...s.members.values()]
+            .filter((m) => m.status === "ACTIVE")
+            .sort((a, b) => (a.role === b.role ? a.joinedAt.localeCompare(b.joinedAt) : a.role === "OWNER" ? -1 : 1))
+            .map((m) => ({ playerId: m.playerId, displayName: this.names.get(m.playerId), role: m.role, status: "ACTIVE" }));
+        return { ...s.space, settings: { ...s.space.settings }, members };
+    }
+}
+function normalizeCode(code) {
+    return code.toUpperCase().replace(/[\s\-_.]/g, "");
+}

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

@@ -406,6 +406,108 @@ export var GameStatusOutput;
         ];
     };
 })(GameStatusOutput || (GameStatusOutput = {}));
+export const LiveMode = {
+    HOSTED: "HOSTED",
+    RELAY: "RELAY",
+};
+export const LiveScope = {
+    GAME: "GAME",
+    SPACE: "SPACE",
+};
+export var LiveCapability;
+(function (LiveCapability) {
+    const memberValidators = {};
+    LiveCapability.validate = (obj, path = "") => {
+        function getMemberValidator(member) {
+            if (memberValidators[member] === undefined) {
+                switch (member) {
+                    case "mode": {
+                        memberValidators["mode"] = new __CompositeValidator([
+                            new __EnumValidator([
+                                "RELAY",
+                                "HOSTED",
+                            ], [
+                                "RELAY",
+                                "HOSTED",
+                            ]),
+                            new __RequiredValidator(),
+                        ]);
+                        break;
+                    }
+                    case "scope": {
+                        memberValidators["scope"] = new __CompositeValidator([
+                            new __EnumValidator([
+                                "GAME",
+                                "SPACE",
+                            ], [
+                                "GAME",
+                                "SPACE",
+                            ]),
+                        ]);
+                        break;
+                    }
+                    case "spectators": {
+                        memberValidators["spectators"] = new __NoOpValidator();
+                        break;
+                    }
+                    case "maxSignalsPerSecond": {
+                        memberValidators["maxSignalsPerSecond"] = new __NoOpValidator();
+                        break;
+                    }
+                    case "maxSignalBytes": {
+                        memberValidators["maxSignalBytes"] = new __NoOpValidator();
+                        break;
+                    }
+                }
+            }
+            return memberValidators[member];
+        }
+        return [
+            ...getMemberValidator("mode").validate(obj.mode, `${path}/mode`),
+            ...getMemberValidator("scope").validate(obj.scope, `${path}/scope`),
+            ...getMemberValidator("spectators").validate(obj.spectators, `${path}/spectators`),
+            ...getMemberValidator("maxSignalsPerSecond").validate(obj.maxSignalsPerSecond, `${path}/maxSignalsPerSecond`),
+            ...getMemberValidator("maxSignalBytes").validate(obj.maxSignalBytes, `${path}/maxSignalBytes`),
+        ];
+    };
+})(LiveCapability || (LiveCapability = {}));
+export var SpaceCapability;
+(function (SpaceCapability) {
+    const memberValidators = {};
+    SpaceCapability.validate = (obj, path = "") => {
+        function getMemberValidator(member) {
+            if (memberValidators[member] === undefined) {
+                switch (member) {
+                    case "maxMembers": {
+                        memberValidators["maxMembers"] = new __CompositeValidator([
+                            new __RequiredValidator(),
+                        ]);
+                        break;
+                    }
+                    case "label": {
+                        memberValidators["label"] = new __NoOpValidator();
+                        break;
+                    }
+                    case "settingsSchema": {
+                        memberValidators["settingsSchema"] = new __NoOpValidator();
+                        break;
+                    }
+                    case "gameConfig": {
+                        memberValidators["gameConfig"] = new __NoOpValidator();
+                        break;
+                    }
+                }
+            }
+            return memberValidators[member];
+        }
+        return [
+            ...getMemberValidator("maxMembers").validate(obj.maxMembers, `${path}/maxMembers`),
+            ...getMemberValidator("label").validate(obj.label, `${path}/label`),
+            ...getMemberValidator("settingsSchema").validate(obj.settingsSchema, `${path}/settingsSchema`),
+            ...getMemberValidator("gameConfig").validate(obj.gameConfig, `${path}/gameConfig`),
+        ];
+    };
+})(SpaceCapability || (SpaceCapability = {}));
 export var GameTypeMetadata;
 (function (GameTypeMetadata) {
     const memberValidators = {};
@@ -485,6 +587,14 @@ export var GameTypeMetadata;
                         memberValidators["hasSaveFileEditor"] = new __NoOpValidator();
                         break;
                     }
+                    case "spaces": {
+                        memberValidators["spaces"] = new __CompositeStructureValidator(new __NoOpValidator(), SpaceCapability.validate);
+                        break;
+                    }
+                    case "live": {
+                        memberValidators["live"] = new __CompositeStructureValidator(new __NoOpValidator(), LiveCapability.validate);
+                        break;
+                    }
                 }
             }
             return memberValidators[member];
@@ -505,6 +615,8 @@ export var GameTypeMetadata;
             ...getMemberValidator("hasSaveFiles").validate(obj.hasSaveFiles, `${path}/hasSaveFiles`),
             ...getMemberValidator("hasSaveSummary").validate(obj.hasSaveSummary, `${path}/hasSaveSummary`),
             ...getMemberValidator("hasSaveFileEditor").validate(obj.hasSaveFileEditor, `${path}/hasSaveFileEditor`),
+            ...getMemberValidator("spaces").validate(obj.spaces, `${path}/spaces`),
+            ...getMemberValidator("live").validate(obj.live, `${path}/live`),
         ];
     };
 })(GameTypeMetadata || (GameTypeMetadata = {}));

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

@@ -616,8 +616,10 @@ export const serializeGetMetadataResponse = async (input, ctx) => {
         'hasSaveFiles': [],
         'hasSaveSummary': [],
         'id': [],
+        'live': _ => se_LiveCapability(_, context),
         'maxPlayers': [],
         'minPlayers': [],
+        'spaces': _ => se_SpaceCapability(_, context),
         'spectatorSafe': [],
         'teamPlay': [],
     }));
@@ -1015,9 +1017,26 @@ const se_BotSkillLevelList = (input, context) => {
         return se_BotSkillLevelEntry(entry, context);
     });
 };
+const se_LiveCapability = (input, context) => {
+    return take(input, {
+        'maxSignalBytes': [],
+        'maxSignalsPerSecond': [],
+        'mode': [],
+        'scope': [],
+        'spectators': [],
+    });
+};
 const se_ParticipantIdList = (input, context) => {
     return input.filter((e) => e != null);
 };
+const se_SpaceCapability = (input, context) => {
+    return take(input, {
+        'gameConfig': _ => se_Document(_, context),
+        'label': [],
+        'maxMembers': [],
+        'settingsSchema': _ => se_Document(_, context),
+    });
+};
 const se_Document = (input, context) => {
     return input;
 };