@paakd/api 0.0.1 → 0.0.2

package/dist/src/interceptors.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggingInterceptor = createLoggingInterceptor;
+exports.createAuthenticationInterceptor = createAuthenticationInterceptor;
+exports.createCustomerAuthenticationInterceptor = createCustomerAuthenticationInterceptor;
+exports.createHeadersInterceptor = createHeadersInterceptor;
+const connect_1 = require("@connectrpc/connect");
+function defaultRequestLogger(req) {
+    const name = `${req.method.methodKind} ${req.method.toString()}`;
+    return {
+        onRequestHeader(header) {
+            console.log(name, 'request header', header);
+        },
+        onRequestMessage(message) {
+            console.log(name, 'request message', message);
+        },
+        onResponseHeader(header) {
+            console.log(name, 'response header', header);
+        },
+        onResponseMessage(message) {
+            console.log(name, 'response message', message);
+        },
+        onResponseTrailer(trailer) {
+            console.log(name, 'response trailer', trailer);
+        },
+        onError(error) {
+            console.log(name, 'error', error);
+        },
+    };
+}
+function createLoggingInterceptor(reqLogger = defaultRequestLogger) {
+    return next => (req) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const logger = reqLogger(req);
+        const reqIntercepted = interceptRequest(req, logger);
+        let res;
+        try {
+            res = yield next(reqIntercepted);
+        }
+        catch (e) {
+            (_a = logger.onError) === null || _a === void 0 ? void 0 : _a.call(logger, e);
+            throw e;
+        }
+        return interceptResponse(res, logger);
+    });
+}
+function createAuthenticationInterceptor(checkoutConfig) {
+    return next => (req) => __awaiter(this, void 0, void 0, function* () {
+        req.header.set('X-Store-Key', checkoutConfig.storeAPISecret);
+        req.header.set('X-SA-Key', checkoutConfig.storeAccessKey);
+        req.header.set('X-CH-Key', checkoutConfig.salesChannelAPISecret);
+        req.header.set('X-CHA-Key', checkoutConfig.saleChannelAccessKey);
+        return yield next(req);
+    });
+}
+function createCustomerAuthenticationInterceptor(jwtKey) {
+    return next => (req) => __awaiter(this, void 0, void 0, function* () {
+        if (!jwtKey) {
+            throw new connect_1.ConnectError('JWT key is required for customer authentication', connect_1.Code.Unauthenticated);
+        }
+        req.header.set('Authorization', `Bearer ${jwtKey}`);
+        return yield next(req);
+    });
+}
+function interceptRequest(req, logger) {
+    var _a, _b;
+    (_a = logger.onRequestHeader) === null || _a === void 0 ? void 0 : _a.call(logger, req.header);
+    if (req.stream) {
+        return Object.assign(Object.assign({}, req), { message: interceptIterable(req.message, message => { var _a; return (_a = logger.onRequestMessage) === null || _a === void 0 ? void 0 : _a.call(logger, message); }, () => { }, () => { }) });
+    }
+    (_b = logger.onRequestMessage) === null || _b === void 0 ? void 0 : _b.call(logger, req.message);
+    return req;
+}
+function interceptResponse(res, logger) {
+    var _a, _b, _c;
+    (_a = logger.onResponseHeader) === null || _a === void 0 ? void 0 : _a.call(logger, res.header);
+    if (res.stream) {
+        return Object.assign(Object.assign({}, res), { message: interceptIterable(res.message, message => { var _a; return (_a = logger.onResponseMessage) === null || _a === void 0 ? void 0 : _a.call(logger, message); }, e => { var _a; return (_a = logger.onError) === null || _a === void 0 ? void 0 : _a.call(logger, e); }, () => { var _a; return (_a = logger.onResponseTrailer) === null || _a === void 0 ? void 0 : _a.call(logger, res.trailer); }) });
+    }
+    (_b = logger.onResponseMessage) === null || _b === void 0 ? void 0 : _b.call(logger, res.message);
+    (_c = logger.onResponseTrailer) === null || _c === void 0 ? void 0 : _c.call(logger, res.trailer);
+    return res;
+}
+function interceptIterable(original, onNext, onNextReject, onDone) {
+    return {
+        [Symbol.asyncIterator]() {
+            const o = original[Symbol.asyncIterator]();
+            const n = {
+                next(value) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        let result;
+                        try {
+                            result = yield o.next(value);
+                        }
+                        catch (e) {
+                            onNextReject(e);
+                            throw e;
+                        }
+                        if (result.done !== true) {
+                            onNext(result.value);
+                        }
+                        else {
+                            onDone();
+                        }
+                        return result;
+                    });
+                },
+            };
+            if (o.throw) {
+                n.throw = (e) => {
+                    return o.throw(e);
+                };
+            }
+            if (o.return) {
+                n.return = (value) => {
+                    return o.return(value);
+                };
+            }
+            return n;
+        },
+    };
+}
+function createHeadersInterceptor(headers) {
+    return next => (req) => __awaiter(this, void 0, void 0, function* () {
+        if (!headers['x-original-host']) {
+            throw new connect_1.ConnectError('Original host missing from request', connect_1.Code.InvalidArgument);
+        }
+        if (!headers['x-shop-id']) {
+            throw new connect_1.ConnectError('Shop id missing from request', connect_1.Code.InvalidArgument);
+        }
+        if (!headers['x-sitepath']) {
+            throw new connect_1.ConnectError('Sitepath missing from request', connect_1.Code.InvalidArgument);
+        }
+        if (!headers['x-locale']) {
+            throw new connect_1.ConnectError('Locale missing from request', connect_1.Code.InvalidArgument);
+        }
+        if (!headers['x-region']) {
+            throw new connect_1.ConnectError('Region missing from request', connect_1.Code.InvalidArgument);
+        }
+        req.header.set('X-Original-Host', headers['x-original-host']);
+        req.header.set('X-shop-id', headers['x-shop-id']);
+        req.header.set('X-Sitepath', headers['x-sitepath']);
+        req.header.set('X-locale', headers['x-locale']);
+        req.header.set('X-Region', headers['x-region']);
+        return yield next(req);
+    });
+}

package/dist/src/interceptors.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interceptors.spec.d.ts.map

package/dist/src/interceptors.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptors.spec.d.ts","sourceRoot":"","sources":["../../src/interceptors.spec.ts"],"names":[],"mappings":""}