@sparkrewards/sra-sdk 0.0.1

package/dist-es/server/AppAPIService.js

@@ -0,0 +1,366 @@
+import { serializeFrameworkException } from "../protocols/Aws_restJson1";
+import { DeleteUserSerializer, DeleteUserServerInput, } from "./operations/DeleteUser";
+import { FavoritePlansSerializer, FavoritePlansServerInput, } from "./operations/FavoritePlans";
+import { FavoriteShopsSerializer, FavoriteShopsServerInput, } from "./operations/FavoriteShops";
+import { GetShopSerializer, GetShopServerInput, } from "./operations/GetShop";
+import { GetShopPublicSerializer, GetShopPublicServerInput, } from "./operations/GetShopPublic";
+import { GetUserSerializer, GetUserServerInput, } from "./operations/GetUser";
+import { LikeOrgSerializer, LikeOrgServerInput, } from "./operations/LikeOrg";
+import { NearbyShopsSerializer, NearbyShopsServerInput, } from "./operations/NearbyShops";
+import { NearbyShopsPublicSerializer, NearbyShopsPublicServerInput, } from "./operations/NearbyShopsPublic";
+import { NearestShopSerializer, NearestShopServerInput, } from "./operations/NearestShop";
+import { OnboardUserSerializer, OnboardUserServerInput, } from "./operations/OnboardUser";
+import { PinnedShopSerializer, PinnedShopServerInput, } from "./operations/PinnedShop";
+import { PinnedShopPublicSerializer, PinnedShopPublicServerInput, } from "./operations/PinnedShopPublic";
+import { PlanSerializer, PlanServerInput, } from "./operations/Plan";
+import { PlanPublicSerializer, PlanPublicServerInput, } from "./operations/PlanPublic";
+import { PlansSerializer, PlansServerInput, } from "./operations/Plans";
+import { PopularShopsSerializer, PopularShopsServerInput, } from "./operations/PopularShops";
+import { PopularShopsPublicSerializer, PopularShopsPublicServerInput, } from "./operations/PopularShopsPublic";
+import { RadiusShopsSerializer, RadiusShopsServerInput, } from "./operations/RadiusShops";
+import { RecordVisitSerializer, RecordVisitServerInput, } from "./operations/RecordVisit";
+import { RedeemFirstTimeRewardSerializer, RedeemFirstTimeRewardServerInput, } from "./operations/RedeemFirstTimeReward";
+import { RedeemPointRewardSerializer, RedeemPointRewardServerInput, } from "./operations/RedeemPointReward";
+import { RedeemVisitRewardSerializer, RedeemVisitRewardServerInput, } from "./operations/RedeemVisitReward";
+import { SearchShopsPublicSerializer, SearchShopsPublicServerInput, } from "./operations/SearchShopsPublic";
+import { SearchSuggestionSerializer, SearchSuggestionServerInput, } from "./operations/SearchSuggestion";
+import { UpdateUserSerializer, UpdateUserServerInput, } from "./operations/UpdateUser";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, UnknownOperationException as __UnknownOperationException, generateValidationMessage as __generateValidationMessage, generateValidationSummary as __generateValidationSummary, 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";
+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 AppAPIServiceHandler {
+    constructor(service, mux, serializerFactory, serializeFrameworkException, validationCustomizer) {
+        this.service = service;
+        this.mux = mux;
+        this.serializerFactory = serializerFactory;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            return this.serializeFrameworkException(new __UnknownOperationException(), serdeContextBase);
+        }
+        switch (target.operation) {
+            case "DeleteUser": {
+                return handle(request, context, "DeleteUser", this.serializerFactory("DeleteUser"), this.service.DeleteUser, this.serializeFrameworkException, DeleteUserServerInput.validate, this.validationCustomizer);
+            }
+            case "FavoritePlans": {
+                return handle(request, context, "FavoritePlans", this.serializerFactory("FavoritePlans"), this.service.FavoritePlans, this.serializeFrameworkException, FavoritePlansServerInput.validate, this.validationCustomizer);
+            }
+            case "FavoriteShops": {
+                return handle(request, context, "FavoriteShops", this.serializerFactory("FavoriteShops"), this.service.FavoriteShops, this.serializeFrameworkException, FavoriteShopsServerInput.validate, this.validationCustomizer);
+            }
+            case "GetShop": {
+                return handle(request, context, "GetShop", this.serializerFactory("GetShop"), this.service.GetShop, this.serializeFrameworkException, GetShopServerInput.validate, this.validationCustomizer);
+            }
+            case "GetShopPublic": {
+                return handle(request, context, "GetShopPublic", this.serializerFactory("GetShopPublic"), this.service.GetShopPublic, this.serializeFrameworkException, GetShopPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "GetUser": {
+                return handle(request, context, "GetUser", this.serializerFactory("GetUser"), this.service.GetUser, this.serializeFrameworkException, GetUserServerInput.validate, this.validationCustomizer);
+            }
+            case "LikeOrg": {
+                return handle(request, context, "LikeOrg", this.serializerFactory("LikeOrg"), this.service.LikeOrg, this.serializeFrameworkException, LikeOrgServerInput.validate, this.validationCustomizer);
+            }
+            case "NearbyShops": {
+                return handle(request, context, "NearbyShops", this.serializerFactory("NearbyShops"), this.service.NearbyShops, this.serializeFrameworkException, NearbyShopsServerInput.validate, this.validationCustomizer);
+            }
+            case "NearbyShopsPublic": {
+                return handle(request, context, "NearbyShopsPublic", this.serializerFactory("NearbyShopsPublic"), this.service.NearbyShopsPublic, this.serializeFrameworkException, NearbyShopsPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "NearestShop": {
+                return handle(request, context, "NearestShop", this.serializerFactory("NearestShop"), this.service.NearestShop, this.serializeFrameworkException, NearestShopServerInput.validate, this.validationCustomizer);
+            }
+            case "OnboardUser": {
+                return handle(request, context, "OnboardUser", this.serializerFactory("OnboardUser"), this.service.OnboardUser, this.serializeFrameworkException, OnboardUserServerInput.validate, this.validationCustomizer);
+            }
+            case "PinnedShop": {
+                return handle(request, context, "PinnedShop", this.serializerFactory("PinnedShop"), this.service.PinnedShop, this.serializeFrameworkException, PinnedShopServerInput.validate, this.validationCustomizer);
+            }
+            case "PinnedShopPublic": {
+                return handle(request, context, "PinnedShopPublic", this.serializerFactory("PinnedShopPublic"), this.service.PinnedShopPublic, this.serializeFrameworkException, PinnedShopPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "Plan": {
+                return handle(request, context, "Plan", this.serializerFactory("Plan"), this.service.Plan, this.serializeFrameworkException, PlanServerInput.validate, this.validationCustomizer);
+            }
+            case "PlanPublic": {
+                return handle(request, context, "PlanPublic", this.serializerFactory("PlanPublic"), this.service.PlanPublic, this.serializeFrameworkException, PlanPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "Plans": {
+                return handle(request, context, "Plans", this.serializerFactory("Plans"), this.service.Plans, this.serializeFrameworkException, PlansServerInput.validate, this.validationCustomizer);
+            }
+            case "PopularShops": {
+                return handle(request, context, "PopularShops", this.serializerFactory("PopularShops"), this.service.PopularShops, this.serializeFrameworkException, PopularShopsServerInput.validate, this.validationCustomizer);
+            }
+            case "PopularShopsPublic": {
+                return handle(request, context, "PopularShopsPublic", this.serializerFactory("PopularShopsPublic"), this.service.PopularShopsPublic, this.serializeFrameworkException, PopularShopsPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "RadiusShops": {
+                return handle(request, context, "RadiusShops", this.serializerFactory("RadiusShops"), this.service.RadiusShops, this.serializeFrameworkException, RadiusShopsServerInput.validate, this.validationCustomizer);
+            }
+            case "RecordVisit": {
+                return handle(request, context, "RecordVisit", this.serializerFactory("RecordVisit"), this.service.RecordVisit, this.serializeFrameworkException, RecordVisitServerInput.validate, this.validationCustomizer);
+            }
+            case "RedeemFirstTimeReward": {
+                return handle(request, context, "RedeemFirstTimeReward", this.serializerFactory("RedeemFirstTimeReward"), this.service.RedeemFirstTimeReward, this.serializeFrameworkException, RedeemFirstTimeRewardServerInput.validate, this.validationCustomizer);
+            }
+            case "RedeemPointReward": {
+                return handle(request, context, "RedeemPointReward", this.serializerFactory("RedeemPointReward"), this.service.RedeemPointReward, this.serializeFrameworkException, RedeemPointRewardServerInput.validate, this.validationCustomizer);
+            }
+            case "RedeemVisitReward": {
+                return handle(request, context, "RedeemVisitReward", this.serializerFactory("RedeemVisitReward"), this.service.RedeemVisitReward, this.serializeFrameworkException, RedeemVisitRewardServerInput.validate, this.validationCustomizer);
+            }
+            case "SearchShopsPublic": {
+                return handle(request, context, "SearchShopsPublic", this.serializerFactory("SearchShopsPublic"), this.service.SearchShopsPublic, this.serializeFrameworkException, SearchShopsPublicServerInput.validate, this.validationCustomizer);
+            }
+            case "SearchSuggestion": {
+                return handle(request, context, "SearchSuggestion", this.serializerFactory("SearchSuggestion"), this.service.SearchSuggestion, this.serializeFrameworkException, SearchSuggestionServerInput.validate, this.validationCustomizer);
+            }
+            case "UpdateUser": {
+                return handle(request, context, "UpdateUser", this.serializerFactory("UpdateUser"), this.service.UpdateUser, this.serializeFrameworkException, UpdateUserServerInput.validate, this.validationCustomizer);
+            }
+        }
+    }
+}
+export const getAppAPIServiceHandler = (service) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('DELETE', [
+            { type: 'path_literal', value: "user" },
+        ], [], { service: "AppAPI", operation: "DeleteUser" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plans" },
+            { type: 'path_literal', value: "favorite" },
+        ], [
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "FavoritePlans" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "favorite" },
+        ], [], { service: "AppAPI", operation: "FavoriteShops" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "shop" },
+            { type: 'path' },
+        ], [], { service: "AppAPI", operation: "GetShop" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "shop" },
+            { type: 'path' },
+        ], [], { service: "AppAPI", operation: "GetShopPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "user" },
+        ], [], { service: "AppAPI", operation: "GetUser" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "user" },
+            { type: 'path_literal', value: "like" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "LikeOrg" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+        ], [], { service: "AppAPI", operation: "NearbyShops" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+        ], [], { service: "AppAPI", operation: "NearbyShopsPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "nearest" },
+        ], [
+            { type: 'query', key: "shop_name" },
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "NearestShop" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "user" },
+            { type: 'path_literal', value: "onboard" },
+        ], [], { service: "AppAPI", operation: "OnboardUser" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "pinned" },
+        ], [
+            { type: 'query', key: "shop_id" },
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "PinnedShop" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "pinned" },
+        ], [
+            { type: 'query', key: "shop_id" },
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "PinnedShopPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plan" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "Plan" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "plan" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "PlanPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plans" },
+        ], [
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "Plans" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "popular" },
+        ], [], { service: "AppAPI", operation: "PopularShops" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "popular" },
+        ], [], { service: "AppAPI", operation: "PopularShopsPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "radius" },
+        ], [], { service: "AppAPI", operation: "RadiusShops" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "visit" },
+        ], [
+            { type: 'query', key: "shop_id" },
+            { type: 'query', key: "timestamp" },
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "RecordVisit" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "rewards" },
+            { type: 'path_literal', value: "redeem" },
+            { type: 'path_literal', value: "first-time" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "RedeemFirstTimeReward" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "rewards" },
+            { type: 'path_literal', value: "redeem" },
+            { type: 'path_literal', value: "point" },
+        ], [
+            { type: 'query', key: "org_id" },
+            { type: 'query', key: "reward_id" },
+        ], { service: "AppAPI", operation: "RedeemPointReward" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "rewards" },
+            { type: 'path_literal', value: "redeem" },
+            { type: 'path_literal', value: "visit" },
+        ], [
+            { type: 'query', key: "reward_id" },
+        ], { service: "AppAPI", operation: "RedeemVisitReward" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "search" },
+        ], [
+            { type: 'query', key: "q" },
+        ], { service: "AppAPI", operation: "SearchShopsPublic" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "search" },
+            { type: 'path_literal', value: "suggestion" },
+        ], [
+            { type: 'query', key: "q" },
+        ], { service: "AppAPI", operation: "SearchSuggestion" }),
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "user" },
+        ], [], { service: "AppAPI", operation: "UpdateUser" }),
+    ]);
+    const serFn = (op) => {
+        switch (op) {
+            case "DeleteUser": return new DeleteUserSerializer();
+            case "FavoritePlans": return new FavoritePlansSerializer();
+            case "FavoriteShops": return new FavoriteShopsSerializer();
+            case "GetShop": return new GetShopSerializer();
+            case "GetShopPublic": return new GetShopPublicSerializer();
+            case "GetUser": return new GetUserSerializer();
+            case "LikeOrg": return new LikeOrgSerializer();
+            case "NearbyShops": return new NearbyShopsSerializer();
+            case "NearbyShopsPublic": return new NearbyShopsPublicSerializer();
+            case "NearestShop": return new NearestShopSerializer();
+            case "OnboardUser": return new OnboardUserSerializer();
+            case "PinnedShop": return new PinnedShopSerializer();
+            case "PinnedShopPublic": return new PinnedShopPublicSerializer();
+            case "Plan": return new PlanSerializer();
+            case "PlanPublic": return new PlanPublicSerializer();
+            case "Plans": return new PlansSerializer();
+            case "PopularShops": return new PopularShopsSerializer();
+            case "PopularShopsPublic": return new PopularShopsPublicSerializer();
+            case "RadiusShops": return new RadiusShopsSerializer();
+            case "RecordVisit": return new RecordVisitSerializer();
+            case "RedeemFirstTimeReward": return new RedeemFirstTimeRewardSerializer();
+            case "RedeemPointReward": return new RedeemPointRewardSerializer();
+            case "RedeemVisitReward": return new RedeemVisitRewardSerializer();
+            case "SearchShopsPublic": return new SearchShopsPublicSerializer();
+            case "SearchSuggestion": return new SearchSuggestionSerializer();
+            case "UpdateUser": return new UpdateUserSerializer();
+        }
+    };
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: __generateValidationSummary(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: __generateValidationMessage(failure)
+            }))
+        };
+    };
+    return new AppAPIServiceHandler(service, mux, serFn, serializeFrameworkException, customizer);
+};

package/dist-es/server/index.js

@@ -0,0 +1,2 @@
+export * from "./operations";
+export * from "./AppAPIService";

package/dist-es/server/operations/DeleteUser.js

@@ -0,0 +1,115 @@
+import { DeleteUserInput, } from "../../models/models_0";
+import { deserializeDeleteUserRequest, serializeDeleteUserResponse, serializeFrameworkException, serializeRuntimeErrorError, serializeValidationExceptionError, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, generateValidationMessage as __generateValidationMessage, generateValidationSummary as __generateValidationSummary, 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 DeleteUserServerInput;
+(function (DeleteUserServerInput) {
+    DeleteUserServerInput.validate = DeleteUserInput.validate;
+})(DeleteUserServerInput || (DeleteUserServerInput = {}));
+export class DeleteUserSerializer {
+    constructor() {
+        this.serialize = serializeDeleteUserResponse;
+        this.deserialize = deserializeDeleteUserRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return serializeValidationExceptionError(error, ctx);
+            }
+            case "RuntimeError": {
+                return serializeRuntimeErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getDeleteUserHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('DELETE', [
+            { type: 'path_literal', value: "user" },
+        ], [], { service: "AppAPI", operation: "DeleteUser" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: __generateValidationSummary(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: __generateValidationMessage(failure)
+            }))
+        };
+    };
+    return new DeleteUserHandler(operation, mux, new DeleteUserSerializer(), 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 DeleteUserHandler {
+    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 software.amazon.smithy.app#AppAPI.DeleteUser. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "DeleteUser", this.serializer, this.operation, this.serializeFrameworkException, DeleteUserServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/server/operations/FavoritePlans.js

@@ -0,0 +1,119 @@
+import { PlansListInput, } from "../../models/models_0";
+import { deserializeFavoritePlansRequest, serializeFavoritePlansResponse, serializeFrameworkException, serializeRuntimeErrorError, serializeValidationExceptionError, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, generateValidationMessage as __generateValidationMessage, generateValidationSummary as __generateValidationSummary, 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 FavoritePlansServerInput;
+(function (FavoritePlansServerInput) {
+    FavoritePlansServerInput.validate = PlansListInput.validate;
+})(FavoritePlansServerInput || (FavoritePlansServerInput = {}));
+export class FavoritePlansSerializer {
+    constructor() {
+        this.serialize = serializeFavoritePlansResponse;
+        this.deserialize = deserializeFavoritePlansRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return serializeValidationExceptionError(error, ctx);
+            }
+            case "RuntimeError": {
+                return serializeRuntimeErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getFavoritePlansHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plans" },
+            { type: 'path_literal', value: "favorite" },
+        ], [
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "FavoritePlans" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: __generateValidationSummary(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: __generateValidationMessage(failure)
+            }))
+        };
+    };
+    return new FavoritePlansHandler(operation, mux, new FavoritePlansSerializer(), 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 FavoritePlansHandler {
+    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 software.amazon.smithy.app#AppAPI.FavoritePlans. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "FavoritePlans", this.serializer, this.operation, this.serializeFrameworkException, FavoritePlansServerInput.validate, this.validationCustomizer);
+    }
+}