@sparkrewards/sra-sdk 0.0.1

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

@@ -0,0 +1,116 @@
+import { ShopListInput, } from "../../models/models_0";
+import { deserializeFavoriteShopsRequest, serializeFavoriteShopsResponse, 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 FavoriteShopsServerInput;
+(function (FavoriteShopsServerInput) {
+    FavoriteShopsServerInput.validate = ShopListInput.validate;
+})(FavoriteShopsServerInput || (FavoriteShopsServerInput = {}));
+export class FavoriteShopsSerializer {
+    constructor() {
+        this.serialize = serializeFavoriteShopsResponse;
+        this.deserialize = deserializeFavoriteShopsRequest;
+    }
+    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 getFavoriteShopsHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "favorite" },
+        ], [], { service: "AppAPI", operation: "FavoriteShops" }),
+    ]);
+    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 FavoriteShopsHandler(operation, mux, new FavoriteShopsSerializer(), 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 FavoriteShopsHandler {
+    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.FavoriteShops. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "FavoriteShops", this.serializer, this.operation, this.serializeFrameworkException, FavoriteShopsServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,120 @@
+import { GetShopInput, } from "../../models/models_0";
+import { deserializeGetShopRequest, serializeFrameworkException, serializeGetShopResponse, serializeNotFoundErrorError, 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 GetShopServerInput;
+(function (GetShopServerInput) {
+    GetShopServerInput.validate = GetShopInput.validate;
+})(GetShopServerInput || (GetShopServerInput = {}));
+export class GetShopSerializer {
+    constructor() {
+        this.serialize = serializeGetShopResponse;
+        this.deserialize = deserializeGetShopRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError", "NotFoundError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return serializeValidationExceptionError(error, ctx);
+            }
+            case "RuntimeError": {
+                return serializeRuntimeErrorError(error, ctx);
+            }
+            case "NotFoundError": {
+                return serializeNotFoundErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getGetShopHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "shop" },
+            { type: 'path' },
+        ], [], { service: "AppAPI", operation: "GetShop" }),
+    ]);
+    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 GetShopHandler(operation, mux, new GetShopSerializer(), 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 GetShopHandler {
+    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.GetShop. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetShop", this.serializer, this.operation, this.serializeFrameworkException, GetShopServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,121 @@
+import { GetShopInput, } from "../../models/models_0";
+import { deserializeGetShopPublicRequest, serializeFrameworkException, serializeGetShopPublicResponse, serializeNotFoundErrorError, 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 GetShopPublicServerInput;
+(function (GetShopPublicServerInput) {
+    GetShopPublicServerInput.validate = GetShopInput.validate;
+})(GetShopPublicServerInput || (GetShopPublicServerInput = {}));
+export class GetShopPublicSerializer {
+    constructor() {
+        this.serialize = serializeGetShopPublicResponse;
+        this.deserialize = deserializeGetShopPublicRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError", "NotFoundError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return serializeValidationExceptionError(error, ctx);
+            }
+            case "RuntimeError": {
+                return serializeRuntimeErrorError(error, ctx);
+            }
+            case "NotFoundError": {
+                return serializeNotFoundErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getGetShopPublicHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        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" }),
+    ]);
+    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 GetShopPublicHandler(operation, mux, new GetShopPublicSerializer(), 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 GetShopPublicHandler {
+    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.GetShopPublic. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetShopPublic", this.serializer, this.operation, this.serializeFrameworkException, GetShopPublicServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,115 @@
+import { GetUserInput, } from "../../models/models_0";
+import { deserializeGetUserRequest, serializeFrameworkException, serializeGetUserResponse, 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 GetUserServerInput;
+(function (GetUserServerInput) {
+    GetUserServerInput.validate = GetUserInput.validate;
+})(GetUserServerInput || (GetUserServerInput = {}));
+export class GetUserSerializer {
+    constructor() {
+        this.serialize = serializeGetUserResponse;
+        this.deserialize = deserializeGetUserRequest;
+    }
+    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 getGetUserHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "user" },
+        ], [], { service: "AppAPI", operation: "GetUser" }),
+    ]);
+    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 GetUserHandler(operation, mux, new GetUserSerializer(), 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 GetUserHandler {
+    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.GetUser. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetUser", this.serializer, this.operation, this.serializeFrameworkException, GetUserServerInput.validate, this.validationCustomizer);
+    }
+}

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

@@ -0,0 +1,118 @@
+import { LikeOrgInput, } from "../../models/models_0";
+import { deserializeLikeOrgRequest, serializeFrameworkException, serializeLikeOrgResponse, 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 LikeOrgServerInput;
+(function (LikeOrgServerInput) {
+    LikeOrgServerInput.validate = LikeOrgInput.validate;
+})(LikeOrgServerInput || (LikeOrgServerInput = {}));
+export class LikeOrgSerializer {
+    constructor() {
+        this.serialize = serializeLikeOrgResponse;
+        this.deserialize = deserializeLikeOrgRequest;
+    }
+    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 getLikeOrgHandler = (operation) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('PUT', [
+            { type: 'path_literal', value: "user" },
+            { type: 'path_literal', value: "like" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "LikeOrg" }),
+    ]);
+    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 LikeOrgHandler(operation, mux, new LikeOrgSerializer(), 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 LikeOrgHandler {
+    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.LikeOrg. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "LikeOrg", this.serializer, this.operation, this.serializeFrameworkException, LikeOrgServerInput.validate, this.validationCustomizer);
+    }
+}