@anweather/game-plugin-ssdk 1.2.0

package/dist-es/src/server/operations/IsConfigMove.js

@@ -0,0 +1,95 @@
+import { IsConfigMoveInput, } from "../../models/models_0";
+import { deserializeIsConfigMoveRequest, serializeFrameworkException, serializeIsConfigMoveResponse, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var IsConfigMoveServerInput;
+(function (IsConfigMoveServerInput) {
+    IsConfigMoveServerInput.validate = IsConfigMoveInput.validate;
+})(IsConfigMoveServerInput || (IsConfigMoveServerInput = {}));
+export class IsConfigMoveSerializer {
+    serialize = serializeIsConfigMoveResponse;
+    deserialize = deserializeIsConfigMoveRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getIsConfigMoveHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "is-config" },
+        ], [], { service: "GamePlugin", operation: "IsConfigMove" }),
+    ]);
+    return new IsConfigMoveHandler(operation, mux, new IsConfigMoveSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class IsConfigMoveHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.IsConfigMove. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "IsConfigMove", this.serializer, this.operation, this.serializeFrameworkException, IsConfigMoveServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/IsOutOfTurnMove.js

@@ -0,0 +1,95 @@
+import { IsOutOfTurnMoveInput, } from "../../models/models_0";
+import { deserializeIsOutOfTurnMoveRequest, serializeFrameworkException, serializeIsOutOfTurnMoveResponse, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var IsOutOfTurnMoveServerInput;
+(function (IsOutOfTurnMoveServerInput) {
+    IsOutOfTurnMoveServerInput.validate = IsOutOfTurnMoveInput.validate;
+})(IsOutOfTurnMoveServerInput || (IsOutOfTurnMoveServerInput = {}));
+export class IsOutOfTurnMoveSerializer {
+    serialize = serializeIsOutOfTurnMoveResponse;
+    deserialize = deserializeIsOutOfTurnMoveRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getIsOutOfTurnMoveHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "is-out-of-turn" },
+        ], [], { service: "GamePlugin", operation: "IsOutOfTurnMove" }),
+    ]);
+    return new IsOutOfTurnMoveHandler(operation, mux, new IsOutOfTurnMoveSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class IsOutOfTurnMoveHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.IsOutOfTurnMove. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "IsOutOfTurnMove", this.serializer, this.operation, this.serializeFrameworkException, IsOutOfTurnMoveServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/SelectBotMove.js

@@ -0,0 +1,95 @@
+import { SelectBotMoveInput, } from "../../models/models_0";
+import { deserializeSelectBotMoveRequest, serializeFrameworkException, serializeSelectBotMoveResponse, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var SelectBotMoveServerInput;
+(function (SelectBotMoveServerInput) {
+    SelectBotMoveServerInput.validate = SelectBotMoveInput.validate;
+})(SelectBotMoveServerInput || (SelectBotMoveServerInput = {}));
+export class SelectBotMoveSerializer {
+    serialize = serializeSelectBotMoveResponse;
+    deserialize = deserializeSelectBotMoveRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getSelectBotMoveHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "bots" },
+            { type: 'path_literal', value: "select-move" },
+        ], [], { service: "GamePlugin", operation: "SelectBotMove" }),
+    ]);
+    return new SelectBotMoveHandler(operation, mux, new SelectBotMoveSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class SelectBotMoveHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.SelectBotMove. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "SelectBotMove", this.serializer, this.operation, this.serializeFrameworkException, SelectBotMoveServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/ValidateMove.js

@@ -0,0 +1,95 @@
+import { ValidateMoveInput, } from "../../models/models_0";
+import { deserializeValidateMoveRequest, serializeFrameworkException, serializeValidateMoveResponse, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var ValidateMoveServerInput;
+(function (ValidateMoveServerInput) {
+    ValidateMoveServerInput.validate = ValidateMoveInput.validate;
+})(ValidateMoveServerInput || (ValidateMoveServerInput = {}));
+export class ValidateMoveSerializer {
+    serialize = serializeValidateMoveResponse;
+    deserialize = deserializeValidateMoveRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getValidateMoveHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "validate" },
+        ], [], { service: "GamePlugin", operation: "ValidateMove" }),
+    ]);
+    return new ValidateMoveHandler(operation, mux, new ValidateMoveSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class ValidateMoveHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.ValidateMove. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "ValidateMove", this.serializer, this.operation, this.serializeFrameworkException, ValidateMoveServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/index.js

@@ -0,0 +1,15 @@
+export * from "./ApplyMove";
+export * from "./ApplySaveFileEdit";
+export * from "./AssignParticipants";
+export * from "./DescribeSaveFile";
+export * from "./GetGameResult";
+export * from "./GetGameStatus";
+export * from "./GetMetadata";
+export * from "./GetPlayerView";
+export * from "./GetSaveFileEditorState";
+export * from "./Health";
+export * from "./InitializeGame";
+export * from "./IsConfigMove";
+export * from "./IsOutOfTurnMove";
+export * from "./SelectBotMove";
+export * from "./ValidateMove";