@anweather/game-plugin-ssdk 1.2.0

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

@@ -0,0 +1,95 @@
+import { PluginStateOnlyInput, } from "../../models/models_0";
+import { deserializeGetGameResultRequest, serializeFrameworkException, serializeGetGameResultResponse, } 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 GetGameResultServerInput;
+(function (GetGameResultServerInput) {
+    GetGameResultServerInput.validate = PluginStateOnlyInput.validate;
+})(GetGameResultServerInput || (GetGameResultServerInput = {}));
+export class GetGameResultSerializer {
+    serialize = serializeGetGameResultResponse;
+    deserialize = deserializeGetGameResultRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getGetGameResultHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "result" },
+        ], [], { service: "GamePlugin", operation: "GetGameResult" }),
+    ]);
+    return new GetGameResultHandler(operation, mux, new GetGameResultSerializer(), 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 GetGameResultHandler {
+    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.GetGameResult. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetGameResult", this.serializer, this.operation, this.serializeFrameworkException, GetGameResultServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,95 @@
+import { PluginStateOnlyInput, } from "../../models/models_0";
+import { deserializeGetGameStatusRequest, serializeFrameworkException, serializeGetGameStatusResponse, } 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 GetGameStatusServerInput;
+(function (GetGameStatusServerInput) {
+    GetGameStatusServerInput.validate = PluginStateOnlyInput.validate;
+})(GetGameStatusServerInput || (GetGameStatusServerInput = {}));
+export class GetGameStatusSerializer {
+    serialize = serializeGetGameStatusResponse;
+    deserialize = deserializeGetGameStatusRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getGetGameStatusHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "status" },
+        ], [], { service: "GamePlugin", operation: "GetGameStatus" }),
+    ]);
+    return new GetGameStatusHandler(operation, mux, new GetGameStatusSerializer(), 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 GetGameStatusHandler {
+    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.GetGameStatus. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetGameStatus", this.serializer, this.operation, this.serializeFrameworkException, GetGameStatusServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,93 @@
+import { deserializeGetMetadataRequest, serializeFrameworkException, serializeGetMetadataResponse, } 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 GetMetadataServerInput;
+(function (GetMetadataServerInput) {
+    GetMetadataServerInput.validate = () => [];
+})(GetMetadataServerInput || (GetMetadataServerInput = {}));
+export class GetMetadataSerializer {
+    serialize = serializeGetMetadataResponse;
+    deserialize = deserializeGetMetadataRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getGetMetadataHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "metadata" },
+        ], [], { service: "GamePlugin", operation: "GetMetadata" }),
+    ]);
+    return new GetMetadataHandler(operation, mux, new GetMetadataSerializer(), 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 GetMetadataHandler {
+    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.GetMetadata. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetMetadata", this.serializer, this.operation, this.serializeFrameworkException, GetMetadataServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,95 @@
+import { GetPlayerViewInput, } from "../../models/models_0";
+import { deserializeGetPlayerViewRequest, serializeFrameworkException, serializeGetPlayerViewResponse, } 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 GetPlayerViewServerInput;
+(function (GetPlayerViewServerInput) {
+    GetPlayerViewServerInput.validate = GetPlayerViewInput.validate;
+})(GetPlayerViewServerInput || (GetPlayerViewServerInput = {}));
+export class GetPlayerViewSerializer {
+    serialize = serializeGetPlayerViewResponse;
+    deserialize = deserializeGetPlayerViewRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getGetPlayerViewHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "player-view" },
+        ], [], { service: "GamePlugin", operation: "GetPlayerView" }),
+    ]);
+    return new GetPlayerViewHandler(operation, mux, new GetPlayerViewSerializer(), 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 GetPlayerViewHandler {
+    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.GetPlayerView. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetPlayerView", this.serializer, this.operation, this.serializeFrameworkException, GetPlayerViewServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,95 @@
+import { GetSaveFileEditorStateInput, } from "../../models/models_0";
+import { deserializeGetSaveFileEditorStateRequest, serializeFrameworkException, serializeGetSaveFileEditorStateResponse, } 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 GetSaveFileEditorStateServerInput;
+(function (GetSaveFileEditorStateServerInput) {
+    GetSaveFileEditorStateServerInput.validate = GetSaveFileEditorStateInput.validate;
+})(GetSaveFileEditorStateServerInput || (GetSaveFileEditorStateServerInput = {}));
+export class GetSaveFileEditorStateSerializer {
+    serialize = serializeGetSaveFileEditorStateResponse;
+    deserialize = deserializeGetSaveFileEditorStateRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getGetSaveFileEditorStateHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "editor-state" },
+        ], [], { service: "GamePlugin", operation: "GetSaveFileEditorState" }),
+    ]);
+    return new GetSaveFileEditorStateHandler(operation, mux, new GetSaveFileEditorStateSerializer(), 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 GetSaveFileEditorStateHandler {
+    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.GetSaveFileEditorState. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetSaveFileEditorState", this.serializer, this.operation, this.serializeFrameworkException, GetSaveFileEditorStateServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,93 @@
+import { deserializeHealthRequest, serializeFrameworkException, serializeHealthResponse, } 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 HealthServerInput;
+(function (HealthServerInput) {
+    HealthServerInput.validate = () => [];
+})(HealthServerInput || (HealthServerInput = {}));
+export class HealthSerializer {
+    serialize = serializeHealthResponse;
+    deserialize = deserializeHealthRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getHealthHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "health" },
+        ], [], { service: "GamePlugin", operation: "Health" }),
+    ]);
+    return new HealthHandler(operation, mux, new HealthSerializer(), 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 HealthHandler {
+    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.Health. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "Health", this.serializer, this.operation, this.serializeFrameworkException, HealthServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,95 @@
+import { InitializeGameInput, } from "../../models/models_0";
+import { deserializeInitializeGameRequest, serializeFrameworkException, serializeInitializeGameResponse, } 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 InitializeGameServerInput;
+(function (InitializeGameServerInput) {
+    InitializeGameServerInput.validate = InitializeGameInput.validate;
+})(InitializeGameServerInput || (InitializeGameServerInput = {}));
+export class InitializeGameSerializer {
+    serialize = serializeInitializeGameResponse;
+    deserialize = deserializeInitializeGameRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getInitializeGameHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "initialize" },
+        ], [], { service: "GamePlugin", operation: "InitializeGame" }),
+    ]);
+    return new InitializeGameHandler(operation, mux, new InitializeGameSerializer(), 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 InitializeGameHandler {
+    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.InitializeGame. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "InitializeGame", this.serializer, this.operation, this.serializeFrameworkException, InitializeGameServerInput.validate, this.validationCustomizer);
+    }
+}