ebag 0.0.2

package/dist/lib/config.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigDir = getConfigDir;
+exports.getConfigPath = getConfigPath;
+exports.getSessionPath = getSessionPath;
+exports.getCachePath = getCachePath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.loadSession = loadSession;
+exports.saveSession = saveSession;
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const DEFAULT_CONFIG = {
+    baseUrl: 'https://www.ebag.bg',
+    algolia: {
+        appId: 'JMJMDQ9HHX',
+        apiKey: '42ca9458d9354298c7016ce9155d8481',
+        host: 'jmjmdq9hhx-dsn.algolia.net',
+    },
+};
+function ensureDir(dir) {
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function getConfigDir() {
+    const override = process.env.EBAG_CONFIG_DIR;
+    if (override) {
+        return override;
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), '.config', 'ebag');
+}
+function readJsonFile(filePath, fallback) {
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJsonFile(filePath, data) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+function writeSessionFile(filePath, data) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+function getConfigPath() {
+    return node_path_1.default.join(getConfigDir(), 'config.json');
+}
+function getSessionPath() {
+    return node_path_1.default.join(getConfigDir(), 'session.json');
+}
+function getCachePath() {
+    return node_path_1.default.join(getConfigDir(), 'cache.json');
+}
+function loadConfig() {
+    const stored = readJsonFile(getConfigPath(), {});
+    const algolia = {
+        appId: stored.algolia?.appId ?? DEFAULT_CONFIG.algolia?.appId ?? 'JMJMDQ9HHX',
+        apiKey: stored.algolia?.apiKey ?? DEFAULT_CONFIG.algolia?.apiKey ?? '42ca9458d9354298c7016ce9155d8481',
+        host: stored.algolia?.host ?? DEFAULT_CONFIG.algolia?.host,
+    };
+    return {
+        ...DEFAULT_CONFIG,
+        ...stored,
+        algolia,
+    };
+}
+function saveConfig(config) {
+    writeJsonFile(getConfigPath(), config);
+}
+function loadSession() {
+    return readJsonFile(getSessionPath(), {});
+}
+function saveSession(session) {
+    writeSessionFile(getSessionPath(), session);
+}
+function loadCache() {
+    return readJsonFile(getCachePath(), { products: {}, orders: {} });
+}
+function saveCache(cache) {
+    writeJsonFile(getCachePath(), cache);
+}

package/dist/lib/cookies.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeCookieInput(value: string): string;
+export declare function validateCookieInput(value: string): "Cookie value is empty." | "Cookie value should be a single header line without newlines." | "Cookie value should look like \"name=value\" pairs from the Cookie header." | null;

package/dist/lib/cookies.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCookieInput = normalizeCookieInput;
+exports.validateCookieInput = validateCookieInput;
+function normalizeCookieInput(value) {
+    const trimmed = value.trim();
+    if (trimmed.toLowerCase().startsWith('cookie:')) {
+        return trimmed.slice('cookie:'.length).trim();
+    }
+    return trimmed;
+}
+function validateCookieInput(value) {
+    if (!value) {
+        return 'Cookie value is empty.';
+    }
+    if (value.includes('\n') || value.includes('\r')) {
+        return 'Cookie value should be a single header line without newlines.';
+    }
+    const parts = value.split(';').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        return 'Cookie value should look like "name=value" pairs from the Cookie header.';
+    }
+    for (const part of parts) {
+        const eqIndex = part.indexOf('=');
+        if (eqIndex <= 0 || eqIndex === part.length - 1) {
+            return 'Cookie value should look like "name=value" pairs from the Cookie header.';
+        }
+    }
+    return null;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './auth';
+export * from './cart';
+export * from './client';
+export * from './config';
+export * from './lists';
+export * from './orders';
+export * from './products';
+export * from './search';
+export * from './types';

package/dist/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth"), exports);
+__exportStar(require("./cart"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./lists"), exports);
+__exportStar(require("./orders"), exports);
+__exportStar(require("./products"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./types"), exports);

package/dist/lib/lists.d.ts

@@ -0,0 +1,4 @@
+import type { Config, ListSummary, Session } from './types';
+export declare function getLists(config: Config, session: Session): Promise<ListSummary[]>;
+export declare function addToList(config: Config, session: Session, listId: number, productId: number, quantity: number): Promise<unknown>;
+export declare function getListItems(config: Config, session: Session, listId: number, page?: number): Promise<Record<string, unknown>>;

package/dist/lib/lists.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLists = getLists;
+exports.addToList = addToList;
+exports.getListItems = getListItems;
+const client_1 = require("./client");
+async function getLists(config, session) {
+    const result = await (0, client_1.requestEbag)(config, session, '/lists/json');
+    return result.data.map((list) => ({
+        id: list.id,
+        name: list.name,
+        type: list.type,
+        publicId: list.public_id ?? null,
+        isReadOnly: list.is_read_only ?? list.isReadOnly,
+        products: list.products?.map((p) => ({
+            productId: p.product_id,
+            quantity: p.quantity,
+        })),
+    }));
+}
+async function addToList(config, session, listId, productId, quantity) {
+    const baseUrl = config.baseUrl || 'https://www.ebag.bg';
+    const body = new URLSearchParams({
+        product_id: String(productId),
+        quantity: String(quantity),
+    });
+    const result = await (0, client_1.requestEbag)(config, session, `/lists/${listId}/items/update`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            origin: baseUrl,
+            referer: `${baseUrl}/search/`,
+        },
+        body,
+    });
+    return result.data;
+}
+async function getListItems(config, session, listId, page = 1) {
+    const result = await (0, client_1.requestEbag)(config, session, `/lists/${listId}/items/json`, { query: { page } });
+    return result.data;
+}

package/dist/lib/orders.d.ts

@@ -0,0 +1,14 @@
+import type { Config, OrderDetail, OrderSummary, Session } from './types';
+export declare function getTimeSlots(config: Config, session: Session): Promise<Record<string, unknown>>;
+export declare function listOrders(config: Config, session: Session, options?: {
+    limit?: number;
+    page?: number;
+    from?: string;
+    to?: string;
+}): Promise<{
+    count: number;
+    results: OrderSummary[];
+    next: string | null;
+    previous: string | null;
+}>;
+export declare function getOrderDetail(config: Config, session: Session, orderId: string): Promise<OrderDetail>;

package/dist/lib/orders.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeSlots = getTimeSlots;
+exports.listOrders = listOrders;
+exports.getOrderDetail = getOrderDetail;
+const config_1 = require("./config");
+const client_1 = require("./client");
+async function getTimeSlots(config, session) {
+    const result = await (0, client_1.requestEbag)(config, session, '/orders/get-time-slots');
+    return result.data;
+}
+function normalizeDate(value) {
+    if (!value)
+        return undefined;
+    const isoMatch = value.match(/(\d{4})-(\d{2})-(\d{2})/);
+    if (isoMatch)
+        return `${isoMatch[1]}-${isoMatch[2]}-${isoMatch[3]}`;
+    const ymdAlt = value.match(/(\d{4})[./](\d{2})[./](\d{2})/);
+    if (ymdAlt)
+        return `${ymdAlt[1]}-${ymdAlt[2]}-${ymdAlt[3]}`;
+    const dmyMatch = value.match(/(\d{2})[./-](\d{2})[./-](\d{4})/);
+    if (dmyMatch)
+        return `${dmyMatch[3]}-${dmyMatch[2]}-${dmyMatch[1]}`;
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return undefined;
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${parsed.getFullYear()}-${pad(parsed.getMonth() + 1)}-${pad(parsed.getDate())}`;
+}
+function normalizeOrderSummary(entry) {
+    const parseNumber = (value) => {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string' && value.trim() !== '') {
+            const parsed = Number(value);
+            return Number.isNaN(parsed) ? undefined : parsed;
+        }
+        return undefined;
+    };
+    return {
+        id: entry.encrypted_id ? String(entry.encrypted_id) : '',
+        shippingDate: entry.shipping_date ? String(entry.shipping_date) : undefined,
+        timeSlotStart: parseNumber(entry.time_slot_start),
+        timeSlotEnd: parseNumber(entry.time_slot_end),
+        timeSlotDisplay: entry.time_slot_display ? String(entry.time_slot_display) : undefined,
+        status: parseNumber(entry.order_status),
+        statusText: entry.order_status_pharmacy
+            ? String(entry.order_status_pharmacy)
+            : entry.order_status_text
+                ? String(entry.order_status_text)
+                : null,
+        finalAmount: entry.final_amount ? String(entry.final_amount) : undefined,
+        finalAmountEur: entry.final_amount_eur ? String(entry.final_amount_eur) : undefined,
+        additionalOrdersCount: typeof entry.additional_orders_count === 'number'
+            ? entry.additional_orders_count
+            : entry.additional_orders_count !== undefined
+                ? Number(entry.additional_orders_count)
+                : undefined,
+        phone: entry.phone ? String(entry.phone) : undefined,
+    };
+}
+function normalizeGroupedItems(groupedItems) {
+    if (!Array.isArray(groupedItems))
+        return [];
+    const items = [];
+    for (const group of groupedItems) {
+        if (!group || typeof group !== 'object')
+            continue;
+        const groupName = group.group_name;
+        const groupItems = group.group_items || [];
+        for (const entry of groupItems) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const item = entry;
+            const product = item.product || undefined;
+            const productSaved = item.product_saved || undefined;
+            const name = product?.name ||
+                item.product_saved_name ||
+                productSaved?.name_bg ||
+                productSaved?.name_en ||
+                'Unknown';
+            const id = typeof product?.id === 'number'
+                ? product.id
+                : product?.id
+                    ? Number(product.id)
+                    : typeof productSaved?.id === 'number'
+                        ? productSaved.id
+                        : productSaved?.id
+                            ? Number(productSaved.id)
+                            : undefined;
+            items.push({
+                id,
+                name,
+                quantity: item.quantity ? String(item.quantity) : undefined,
+                unit: product?.unit_weight_text ? String(product.unit_weight_text) : undefined,
+                price: item.price ? String(item.price) : undefined,
+                priceEur: item.price_eur ? String(item.price_eur) : undefined,
+                regularPrice: item.regular_price ? String(item.regular_price) : undefined,
+                regularPriceEur: item.regular_price_eur ? String(item.regular_price_eur) : undefined,
+                group: groupName ? String(groupName) : undefined,
+            });
+        }
+    }
+    return items;
+}
+function normalizeOrderDetail(payload) {
+    const order = payload.order || {};
+    const parseNumber = (value) => {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string' && value.trim() !== '') {
+            const parsed = Number(value);
+            return Number.isNaN(parsed) ? undefined : parsed;
+        }
+        return undefined;
+    };
+    const addressSerialized = order.address_serialized ? String(order.address_serialized) : '';
+    const city = order.city ? String(order.city) : '';
+    const neighbourhood = order.neighbourhood ? String(order.neighbourhood) : '';
+    const street = order.street ? String(order.street) : '';
+    const address = addressSerialized || [city, neighbourhood, street].filter(Boolean).join(', ');
+    const additionalOrdersRaw = Array.isArray(order.additional_orders)
+        ? order.additional_orders
+        : [];
+    return {
+        id: order.encrypted_id ? String(order.encrypted_id) : '',
+        status: parseNumber(order.order_status),
+        statusText: order.order_status_pharmacy
+            ? String(order.order_status_pharmacy)
+            : order.order_status_text
+                ? String(order.order_status_text)
+                : order.pay_button_text
+                    ? String(order.pay_button_text)
+                    : null,
+        shippingDate: order.shipping_date ? String(order.shipping_date) : undefined,
+        timeSlotDisplay: order.timeslot_display
+            ? String(order.timeslot_display)
+            : order.time_slot_display
+                ? String(order.time_slot_display)
+                : undefined,
+        address: address || undefined,
+        totals: {
+            total: order.total ? String(order.total) : undefined,
+            totalEur: order.total_eur ? String(order.total_eur) : undefined,
+            totalPaid: order.total_price_paid ? String(order.total_price_paid) : undefined,
+            totalPaidEur: order.total_price_paid_eur ? String(order.total_price_paid_eur) : undefined,
+            discount: order.discount ? String(order.discount) : undefined,
+            discountEur: order.discount_eur ? String(order.discount_eur) : undefined,
+            tip: order.tip ? String(order.tip) : undefined,
+            tipEur: order.tip_eur ? String(order.tip_eur) : undefined,
+        },
+        items: normalizeGroupedItems(payload.grouped_items),
+        additionalOrders: additionalOrdersRaw.length
+            ? additionalOrdersRaw.map((entry) => normalizeOrderDetail(entry))
+            : undefined,
+    };
+}
+function filterByDate(orders, from, to) {
+    if (!from && !to)
+        return orders;
+    return orders.filter((order) => {
+        const date = order.shippingDate;
+        if (!date)
+            return false;
+        if (from && date < from)
+            return false;
+        if (to && date > to)
+            return false;
+        return true;
+    });
+}
+async function listOrders(config, session, options = {}) {
+    const limit = options.limit ?? 10;
+    const from = normalizeDate(options.from);
+    const to = normalizeDate(options.to);
+    const hasRange = Boolean(from || to);
+    const results = [];
+    let next = null;
+    let previous = null;
+    const maxPages = options.page ? 1 : hasRange ? 200 : 20;
+    const years = [];
+    if (from && to) {
+        const start = Number(from.slice(0, 4));
+        const end = Number(to.slice(0, 4));
+        for (let year = start; year <= end; year += 1)
+            years.push(year);
+    }
+    else if (from) {
+        const start = Number(from.slice(0, 4));
+        const currentYear = new Date().getFullYear();
+        for (let year = start; year <= currentYear; year += 1)
+            years.push(year);
+    }
+    else if (to) {
+        const end = Number(to.slice(0, 4));
+        const currentYear = new Date().getFullYear();
+        for (let year = end; year <= currentYear; year += 1)
+            years.push(year);
+    }
+    else {
+        years.push(new Date().getFullYear());
+    }
+    const fetchYears = hasRange ? years : [new Date().getFullYear()];
+    for (const year of fetchYears) {
+        let page = options.page ?? 1;
+        let pagesFetched = 0;
+        while (results.length < limit) {
+            const result = await (0, client_1.requestEbag)(config, session, '/orders/list/json', {
+                query: {
+                    page,
+                    year: hasRange ? year : undefined,
+                    exclude_additional_order: 'true',
+                },
+            });
+            const payload = result.data;
+            next = payload.next ?? null;
+            previous = payload.previous ?? null;
+            const normalized = payload.results.map(normalizeOrderSummary);
+            const filtered = filterByDate(normalized, from, to);
+            results.push(...filtered);
+            pagesFetched += 1;
+            if (!payload.next || pagesFetched >= maxPages) {
+                break;
+            }
+            if (from) {
+                const lastDate = normalized[normalized.length - 1]?.shippingDate;
+                if (lastDate && lastDate < from) {
+                    break;
+                }
+            }
+            page += 1;
+        }
+        if (results.length >= limit)
+            break;
+    }
+    return {
+        count: results.slice(0, limit).length,
+        results: results.slice(0, limit),
+        next,
+        previous,
+    };
+}
+function getCachedOrder(cache, orderId) {
+    return cache.orders?.[orderId];
+}
+async function getOrderDetail(config, session, orderId) {
+    const cache = (0, config_1.loadCache)();
+    const cached = getCachedOrder(cache, orderId);
+    if (cached && cached.status === 4) {
+        return cached.detail;
+    }
+    const result = await (0, client_1.requestEbag)(config, session, `/orders/${orderId}/details/json`);
+    const detail = normalizeOrderDetail(result.data);
+    if (!cache.orders) {
+        cache.orders = {};
+    }
+    if (detail.status === 4) {
+        cache.orders[orderId] = {
+            status: detail.status,
+            updatedAt: new Date().toISOString(),
+            detail,
+        };
+        (0, config_1.saveCache)(cache);
+    }
+    return detail;
+}

package/dist/lib/products.d.ts

@@ -0,0 +1,2 @@
+import type { Config, ProductDetail, Session } from './types';
+export declare function getProductById(config: Config, session: Session, productId: number): Promise<ProductDetail>;

package/dist/lib/products.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductById = getProductById;
+const client_1 = require("./client");
+async function getProductById(config, session, productId) {
+    const result = await (0, client_1.requestEbag)(config, session, `/products/${productId}/json`);
+    return result.data;
+}

package/dist/lib/search.d.ts

@@ -0,0 +1,7 @@
+import type { Config, ProductCacheEntry, SearchResult, Session } from './types';
+export declare const PRODUCT_CACHE_TTL_MS: number;
+export declare function isProductCacheFresh(entry: ProductCacheEntry, now?: number, ttlMs?: number): boolean;
+export declare function searchProducts(config: Config, session: Session, query: string, options?: {
+    page?: number;
+    limit?: number;
+}): Promise<SearchResult>;