@lana-commerce/core 11.0.0

package/cjs/json/common.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExpanded = exports.isExpanded = exports.requestFunction = exports.prettyPrintResponseError = exports.requestErrorPrefix = void 0;
+const tslib_1 = require("tslib");
+const klona_1 = require("klona");
+const buildconfig_js_1 = require("../buildconfig.js");
+const request_js_1 = require("../request.js");
+const generateUUID_js_1 = require("../generateUUID.js");
+function isRelayResponse(v) {
+    if (Array.isArray(v) && v.length > 0) {
+        const r = v[0];
+        if (typeof r === "object" && r !== null) {
+            if (r.status && typeof r.status === "number") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function splitPath(path) {
+    const methods = ["POST", "GET", "DELETE"];
+    for (const method of methods) {
+        if (path.startsWith(`${method}:`)) {
+            return { method, path: path.substring(`${method}:`.length) };
+        }
+    }
+    throw new Error(`unknown path method, path should look like: POST:shops.json`);
+}
+function paramValueToString(val) {
+    if (Array.isArray(val)) {
+        return val.map((v) => `${v}`).join(",");
+    }
+    else {
+        return `${val}`;
+    }
+}
+function paramsToString(params) {
+    let out = "";
+    let i = 0;
+    for (const key in params) {
+        const val = params[key];
+        out += `${i++ === 0 ? "?" : "&"}${key}=${paramValueToString(encodeURIComponent(val))}`;
+    }
+    return out;
+}
+function requestErrorPrefix(details) {
+    const fields = [];
+    fields.push(`Url: ${details.url}`);
+    fields.push(`Path: ${details.path}`);
+    if (details.status !== undefined) {
+        fields.push(`Status: ${details.status}`);
+    }
+    if (details.authToken) {
+        fields.push(`AuthToken: ${details.authToken}`);
+    }
+    if (details.uuid) {
+        fields.push(`IdempotencyKey: ${details.uuid}`);
+    }
+    if (details.sessionID) {
+        fields.push(`SessionId: ${details.sessionID}`);
+    }
+    if (details.salesChannelID) {
+        fields.push(`SalesChannelId: ${details.salesChannelID}`);
+    }
+    if (details.deviceID) {
+        fields.push(`DeviceId: ${details.deviceID}`);
+    }
+    if (details.locale) {
+        fields.push(`Locale: ${details.locale}`);
+    }
+    return `JSON API request failed:\n${fields.join("\n")}\n`;
+}
+exports.requestErrorPrefix = requestErrorPrefix;
+function prettyPrintResponseError(err, detailed) {
+    if (err.kind === "error") {
+        const pfx = detailed ? requestErrorPrefix(err.details) : "";
+        return pfx + (0, request_js_1.prettyPrintAPIError)(err.error);
+    }
+    else if (err.kind === "custom_error") {
+        return err.text;
+    }
+    else {
+        const pfx = detailed ? requestErrorPrefix(err.details) : "";
+        switch (err.type) {
+            case "fetch_not_defined":
+                return pfx + '"fetch" not defined, missing polyfill?';
+            case "timeout":
+                return pfx + "HTTP request timed out after all retries";
+            case "no_status":
+                return pfx + "HTTP request didn't respond with status code, connectivity problem?";
+            case "bad_status":
+                return pfx + "HTTP response contains status ≥ 500";
+            case "unrecognized_data_body":
+                return pfx + "HTTP response doesn't look like API data body";
+            case "unrecognized_error_body":
+                return pfx + "HTTP response doesn't look like API error body";
+        }
+    }
+}
+exports.prettyPrintResponseError = prettyPrintResponseError;
+class RequestBuilder {
+    constructor(ctx, methodAndPath) {
+        this._params = {};
+        this._status = undefined;
+        this._extract = undefined;
+        this._data = undefined;
+        this._expansionsSet = new Set();
+        const { method, path } = splitPath(methodAndPath);
+        this._ctx = ctx;
+        this._method = method;
+        this._path = path;
+    }
+    expandRecursive(prefix, v) {
+        for (const key in v) {
+            const c = v[key];
+            if (!c)
+                continue;
+            const k = prefix ? `${prefix}.${key}` : key;
+            this._expansionsSet.add(k);
+            if (typeof c !== "boolean") {
+                this.expandRecursive(k, c);
+            }
+        }
+    }
+    expand(v) {
+        this.expandRecursive("", v);
+        return this;
+    }
+    expectStatus(v) {
+        this._status = v;
+        return this;
+    }
+    extract(v) {
+        this._extract = v;
+        return this;
+    }
+    data(v) {
+        this._data = v;
+        return this;
+    }
+    clone() {
+        const rb = new RequestBuilder(this._ctx, `${this._method}:${this._path}`);
+        for (const k of Array.from(this._expansionsSet)) {
+            rb._expansionsSet.add(k);
+        }
+        rb._params = (0, klona_1.klona)(this._params);
+        return wrapIntoProxy(rb);
+    }
+    send() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const uuid = (0, generateUUID_js_1.generateUUID)();
+            const host = this._ctx["host"] || buildconfig_js_1.BUILD_CONFIG.API_URL;
+            const url = `${host}/relay.json`;
+            const headers = {
+                "Content-Type": "application/json",
+                "Idempotency-Key": uuid,
+            };
+            const deviceID = this._ctx["deviceID"];
+            const sessionID = this._ctx["sessionID"];
+            const salesChannelID = this._ctx["salesChannelID"];
+            const token = this._ctx["token"];
+            const locale = this._ctx["locale"];
+            if (typeof deviceID === "string")
+                headers["Device-Id"] = deviceID;
+            if (typeof sessionID === "string")
+                headers["Session-Id"] = sessionID;
+            if (typeof salesChannelID === "string")
+                headers["Sales-Channel-Id"] = salesChannelID;
+            if (typeof token === "string")
+                headers["Authorization"] = `Bearer ${token}`;
+            if (typeof locale === "string")
+                headers["Locale"] = locale;
+            const req = {
+                method: this._method,
+                url: this._path + paramsToString(this._params),
+                request: this._data,
+                expansions: Array.from(this._expansionsSet).sort(),
+            };
+            const expect = this._ctx["expect"];
+            const details = {
+                path: req.url,
+                url: url,
+                uuid,
+                authToken: typeof token === "string" ? token : undefined,
+                deviceID: typeof deviceID === "string" ? deviceID : undefined,
+                sessionID: typeof sessionID === "string" ? sessionID : undefined,
+                salesChannelID: typeof salesChannelID === "string" ? salesChannelID : undefined,
+                locale: typeof locale === "string" ? locale : undefined,
+            };
+            let respStatus = 0;
+            const resp = yield (0, request_js_1.backoffRetry)((timeout) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                try {
+                    const controller = new AbortController();
+                    const timeoutHandle = setTimeout(() => {
+                        controller.abort();
+                    }, timeout);
+                    if (typeof fetch === "undefined") {
+                        return { type: "expected", value: { kind: "system_error", type: "fetch_not_defined", details } };
+                    }
+                    const resp = yield fetch(url, {
+                        method: "POST",
+                        body: JSON.stringify([req]),
+                        headers,
+                        signal: controller.signal,
+                    });
+                    clearTimeout(timeoutHandle);
+                    if (resp.status === 429)
+                        return { type: "exhausted" };
+                    const isJSON = ((_b = (_a = resp.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.indexOf("application/json")) !== null && _b !== void 0 ? _b : -1) !== -1;
+                    const body = isJSON ? yield resp.json() : undefined;
+                    if (!isRelayResponse(body)) {
+                        respStatus = resp.status;
+                        details.status = resp.status;
+                        if (resp.status >= 200 && resp.status < 300) {
+                            return { type: "unexpected", value: { kind: "system_error", type: "unrecognized_data_body", details } };
+                        }
+                        else if (resp.status >= 500) {
+                            return { type: "unexpected", value: { kind: "system_error", type: "bad_status", details } };
+                        }
+                        else {
+                            return { type: "unexpected", value: { kind: "system_error", type: "unrecognized_error_body", details } };
+                        }
+                    }
+                    else {
+                        const r = body[0];
+                        respStatus = r.status;
+                        details.status = r.status;
+                        if (r.status >= 200 && r.status < 300) {
+                            return { type: "expected", value: { kind: "data", data: r.response, details } };
+                        }
+                        else if (r.status >= 500) {
+                            return { type: "unexpected", value: { kind: "system_error", type: "bad_status", details } };
+                        }
+                        else if (!r.error) {
+                            return { type: "unexpected", value: { kind: "system_error", type: "unrecognized_error_body", details } };
+                        }
+                        else {
+                            return { type: "expected", value: { kind: "error", error: r.error, details } };
+                        }
+                    }
+                }
+                catch (err) {
+                    const isTimeout = err && err.name && err.name === "AbortError";
+                    if (isTimeout) {
+                        return { type: "unexpected", value: { kind: "system_error", type: "timeout", details } };
+                    }
+                    else {
+                        return { type: "unexpected", value: { kind: "system_error", type: "no_status", details } };
+                    }
+                }
+            }), this._ctx["backoffRetryOpts"]);
+            if (this._status !== undefined) {
+                if (expect) {
+                    expect(respStatus).toEqual(this._status);
+                }
+                else if (respStatus !== this._status) {
+                    throw new Error(`${requestErrorPrefix(details)}\nunexpected http response status, got: ${respStatus}, expected: ${this._status}`);
+                }
+            }
+            if (this._extract !== undefined && resp.kind === "data") {
+                for (const name in this._extract) {
+                    const f = this._extract[name];
+                    this._ctx[name] = f(resp.data);
+                }
+            }
+            return resp;
+        });
+    }
+    sendUnwrap() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.send();
+            if (resp.kind === "data") {
+                return resp.data;
+            }
+            else {
+                throw new Error(prettyPrintResponseError(resp));
+            }
+        });
+    }
+}
+function wrapIntoProxy(r) {
+    const proxy = new Proxy(r, {
+        get(target, property) {
+            const p = target[property];
+            if (property in target)
+                return p;
+            if (typeof property === "string") {
+                return (v) => {
+                    target._params[property] = v;
+                    return proxy;
+                };
+            }
+        },
+    });
+    return proxy;
+}
+function requestFunction(ctx, methodAndPath) {
+    return wrapIntoProxy(new RequestBuilder(ctx, methodAndPath));
+}
+exports.requestFunction = requestFunction;
+function isExpanded(v) {
+    if (!v)
+        return false;
+    let hasNonIDKeys = false;
+    for (const key in v) {
+        if (key !== "id") {
+            hasNonIDKeys = true;
+            break;
+        }
+    }
+    return hasNonIDKeys;
+}
+exports.isExpanded = isExpanded;
+function assertExpanded(v) {
+    if (!isExpanded(v))
+        throw new Error(`object is not expanded: ${JSON.stringify(v)}`);
+    return v;
+}
+exports.assertExpanded = assertExpanded;

package/cjs/json/fetchAllItems.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterAllItems = exports.fetchAllItems = void 0;
+const tslib_1 = require("tslib");
+const exceptions_js_1 = require("../exceptions.js");
+const common_js_1 = require("./common.js");
+function applyDefaultLimit(f) {
+    // a hack, can we make params public in there?
+    if (f._params["limit"] === undefined) {
+        f.limit(20);
+    }
+    return f;
+}
+function fetchAllItems(fetcher) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let lastKey = "";
+        let data = [];
+        while (true) {
+            const resp = yield applyDefaultLimit(fetcher.clone()).last_key(lastKey).send();
+            if (resp.kind === "data") {
+                const items = resp.data.items;
+                if (!items || items.length === 0) {
+                    break;
+                }
+                data.push(...items);
+                lastKey = resp.data.last_key;
+                if (!lastKey) {
+                    throw new exceptions_js_1.IterError(`"last_key" is missing in the response, make sure you explicitly specify "sort_by" in the request`);
+                }
+            }
+            else {
+                return resp;
+            }
+        }
+        return { kind: "data", data };
+    });
+}
+exports.fetchAllItems = fetchAllItems;
+function iterAllItems(fetcher) {
+    return tslib_1.__asyncGenerator(this, arguments, function* iterAllItems_1() {
+        let lastKey = "";
+        while (true) {
+            const resp = yield tslib_1.__await(applyDefaultLimit(fetcher.clone()).last_key(lastKey).send());
+            if (resp.kind !== "data") {
+                throw new exceptions_js_1.IterError((0, common_js_1.prettyPrintResponseError)(resp, true));
+            }
+            const items = resp.data.items;
+            if (!items || items.length === 0) {
+                break;
+            }
+            for (const item of items) {
+                yield yield tslib_1.__await(item);
+            }
+            lastKey = resp.data.last_key;
+            if (!lastKey) {
+                throw new exceptions_js_1.IterError(`"last_key" is missing in the response, make sure you explicitly specify "sort_by" in the request`);
+            }
+        }
+    });
+}
+exports.iterAllItems = iterAllItems;