ebag 0.0.2

package/dist/lib/search.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUCT_CACHE_TTL_MS = void 0;
+exports.isProductCacheFresh = isProductCacheFresh;
+exports.searchProducts = searchProducts;
+const config_1 = require("./config");
+const client_1 = require("./client");
+const lists_1 = require("./lists");
+const DEFAULT_FACETS = [
+    'brand_name_bg',
+    'country_of_origin_bg',
+    'hierarchical_categories_bg.lv1',
+];
+exports.PRODUCT_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+function isProductCacheFresh(entry, now = Date.now(), ttlMs = exports.PRODUCT_CACHE_TTL_MS) {
+    const cachedAt = Date.parse(entry.cachedAt);
+    if (!Number.isFinite(cachedAt))
+        return false;
+    return now - cachedAt < ttlMs;
+}
+function normalizeProductFromDetail(data) {
+    const id = Number(data.id);
+    const name = String(data.name || '');
+    const nameEn = data.name_en ? String(data.name_en) : undefined;
+    const price = data.price ? String(data.price) : undefined;
+    const pricePromo = data.price_promo ? String(data.price_promo) : undefined;
+    const currentPrice = data.current_price ? String(data.current_price) : undefined;
+    const mainImageId = data.main_image_id ? String(data.main_image_id) : undefined;
+    const imageUrl = mainImageId
+        ? `https://www.ebag.bg/products/images/${mainImageId}/200/webp`
+        : undefined;
+    const urlSlug = data.url_slug ? String(data.url_slug) : undefined;
+    return {
+        id,
+        name,
+        nameEn,
+        price,
+        pricePromo,
+        currentPrice,
+        imageUrl,
+        urlSlug,
+    };
+}
+function normalizeProductFromAlgolia(hit) {
+    const id = Number(hit.id);
+    const name = String(hit.name_bg || '');
+    const nameEn = hit.name_en ? String(hit.name_en) : undefined;
+    const price = hit.price ? String(hit.price) : undefined;
+    const pricePromo = hit.price_promo ? String(hit.price_promo) : undefined;
+    const currentPrice = hit.current_price ? String(hit.current_price) : undefined;
+    const imageUrl = hit.product_image_absolute_url
+        ? String(hit.product_image_absolute_url)
+        : undefined;
+    const urlSlug = hit.url_slug_bg ? String(hit.url_slug_bg) : undefined;
+    return {
+        id,
+        name,
+        nameEn,
+        price,
+        pricePromo,
+        currentPrice,
+        imageUrl,
+        urlSlug,
+        source: 'algolia',
+    };
+}
+function safeLower(value) {
+    return value.toLocaleLowerCase('bg-BG');
+}
+async function fetchProductDetail(config, session, productId) {
+    const result = await (0, client_1.requestEbag)(config, session, `/products/${productId}/json`);
+    return normalizeProductFromDetail(result.data);
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = [];
+    let index = 0;
+    async function worker() {
+        while (index < items.length) {
+            const current = items[index];
+            index += 1;
+            results.push(await mapper(current));
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
+    await Promise.all(workers);
+    return results;
+}
+async function getProductWithCache(config, session, cache, productId) {
+    const cached = cache.products[String(productId)];
+    if (cached) {
+        if ('product' in cached) {
+            const entry = cached;
+            if (isProductCacheFresh(entry)) {
+                return entry.product;
+            }
+        }
+    }
+    const product = await fetchProductDetail(config, session, productId);
+    cache.products[String(productId)] = {
+        product,
+        cachedAt: new Date().toISOString(),
+    };
+    return product;
+}
+async function searchInLists(config, session, query) {
+    if (!session.cookies) {
+        return [];
+    }
+    const lists = await (0, lists_1.getLists)(config, session);
+    const productIdToLists = new Map();
+    for (const list of lists) {
+        for (const product of list.products || []) {
+            const existing = productIdToLists.get(product.productId) || [];
+            existing.push(list.name);
+            productIdToLists.set(product.productId, existing);
+        }
+    }
+    const cache = (0, config_1.loadCache)();
+    const products = await mapWithConcurrency([...productIdToLists.keys()], 5, async (productId) => getProductWithCache(config, session, cache, productId));
+    cache.updatedAt = new Date().toISOString();
+    (0, config_1.saveCache)(cache);
+    const needle = safeLower(query);
+    return products
+        .map((product) => ({
+        ...product,
+        source: 'list',
+        listNames: productIdToLists.get(product.id) || [],
+    }))
+        .filter((product) => {
+        const name = safeLower(product.name || '');
+        const nameEn = product.nameEn ? safeLower(product.nameEn) : '';
+        return name.includes(needle) || nameEn.includes(needle);
+    });
+}
+async function searchAlgolia(config, query, page, hitsPerPage) {
+    const params = new URLSearchParams({
+        clickAnalytics: 'true',
+        facets: JSON.stringify(DEFAULT_FACETS),
+        filters: '',
+        highlightPostTag: '__/ais-highlight__',
+        highlightPreTag: '__ais-highlight__',
+        maxValuesPerFacet: '50',
+        page: String(page),
+        query,
+        hitsPerPage: String(hitsPerPage),
+    });
+    const body = {
+        requests: [
+            {
+                indexName: 'products',
+                params: params.toString(),
+            },
+        ],
+    };
+    const result = await (0, client_1.requestAlgolia)(config, body);
+    const hits = result.data.results?.[0]?.hits || [];
+    return hits.map(normalizeProductFromAlgolia);
+}
+async function searchProducts(config, session, query, options = {}) {
+    const page = options.page ?? 0;
+    const limit = options.limit ?? 20;
+    const localResults = await searchInLists(config, session, query);
+    const hitsPerPage = Math.max(limit, 20);
+    const remoteResults = await searchAlgolia(config, query, page, hitsPerPage);
+    const merged = [...localResults];
+    const seen = new Set(localResults.map((p) => p.id));
+    for (const item of remoteResults) {
+        if (!seen.has(item.id)) {
+            merged.push(item);
+            seen.add(item.id);
+        }
+    }
+    return {
+        query,
+        results: merged.slice(0, limit),
+        sourceCounts: {
+            list: localResults.length,
+            algolia: remoteResults.length,
+        },
+    };
+}

package/dist/lib/slots.d.ts

@@ -0,0 +1,6 @@
+import type { DeliverySlot } from './types';
+export declare function normalizeSlots(data: Record<string, unknown>): DeliverySlot[];
+export declare function formatSlotTime(value: number): string;
+export declare function formatSlotRange(start: number, end: number): string;
+export declare function formatLoadPercent(value: number): string;
+export declare function sortSlots(a: DeliverySlot, b: DeliverySlot): number;

package/dist/lib/slots.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSlots = normalizeSlots;
+exports.formatSlotTime = formatSlotTime;
+exports.formatSlotRange = formatSlotRange;
+exports.formatLoadPercent = formatLoadPercent;
+exports.sortSlots = sortSlots;
+function normalizeSlots(data) {
+    const slots = [];
+    for (const [date, entries] of Object.entries(data)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const slot = entry;
+            const start = Number(slot.start);
+            const end = Number(slot.end);
+            if (!slot.key || Number.isNaN(start) || Number.isNaN(end))
+                continue;
+            slots.push({
+                date,
+                key: slot.key,
+                start,
+                end,
+                isAvailable: Boolean(slot.is_available),
+                loadPercent: Number(slot.load_percent ?? 0),
+                cutoffAfter: slot.cutoff_after ?? null,
+                isPharmacyRestricted: slot.is_pharmacy_restricted,
+                isBakeryRestricted: slot.is_bakery_restricted,
+            });
+        }
+    }
+    return slots;
+}
+function formatSlotTime(value) {
+    const padded = String(Math.trunc(value)).padStart(4, '0');
+    const hours = padded.slice(0, 2);
+    const minutes = padded.slice(2);
+    return `${hours}:${minutes}`;
+}
+function formatSlotRange(start, end) {
+    return `${formatSlotTime(start)}–${formatSlotTime(end)}`;
+}
+function formatLoadPercent(value) {
+    if (!Number.isFinite(value))
+        return '0%';
+    const rounded = Math.round(value * 10) / 10;
+    return Number.isInteger(rounded) ? `${rounded}%` : `${rounded.toFixed(1)}%`;
+}
+function sortSlots(a, b) {
+    if (a.date !== b.date)
+        return a.date.localeCompare(b.date);
+    return a.start - b.start;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,115 @@
+export type ProductSummary = {
+    id: number;
+    name: string;
+    nameEn?: string;
+    price?: string;
+    pricePromo?: string;
+    currentPrice?: string;
+    currency?: string;
+    imageUrl?: string;
+    urlSlug?: string;
+    source?: 'list' | 'algolia';
+    listNames?: string[];
+};
+export type ProductDetail = Record<string, unknown>;
+export type ListProduct = {
+    productId: number;
+    quantity: number;
+};
+export type ListSummary = {
+    id: number;
+    name: string;
+    type?: string;
+    publicId?: string | null;
+    isReadOnly?: boolean;
+    products?: ListProduct[];
+};
+export type SearchResult = {
+    query: string;
+    results: ProductSummary[];
+    sourceCounts: {
+        list: number;
+        algolia: number;
+    };
+};
+export type Config = {
+    baseUrl?: string;
+    algolia?: {
+        appId: string;
+        apiKey: string;
+        host?: string;
+    };
+};
+export type Session = {
+    cookies?: string;
+    updatedAt?: string;
+    userAgent?: string;
+};
+export type ProductCacheEntry = {
+    product: ProductSummary;
+    cachedAt: string;
+};
+export type Cache = {
+    products: Record<string, ProductSummary | ProductCacheEntry>;
+    orders?: Record<string, {
+        status?: number;
+        updatedAt?: string;
+        detail: OrderDetail;
+    }>;
+    updatedAt?: string;
+};
+export type DeliverySlot = {
+    date: string;
+    key: string;
+    start: number;
+    end: number;
+    isAvailable: boolean;
+    loadPercent: number;
+    cutoffAfter?: string | null;
+    isPharmacyRestricted?: boolean;
+    isBakeryRestricted?: boolean;
+};
+export type OrderSummary = {
+    id: string;
+    shippingDate?: string;
+    timeSlotStart?: number;
+    timeSlotEnd?: number;
+    timeSlotDisplay?: string;
+    status?: number;
+    statusText?: string | null;
+    finalAmount?: string;
+    finalAmountEur?: string;
+    additionalOrdersCount?: number;
+    phone?: string;
+};
+export type OrderItem = {
+    id?: number;
+    name: string;
+    quantity?: string;
+    unit?: string;
+    price?: string;
+    priceEur?: string;
+    regularPrice?: string;
+    regularPriceEur?: string;
+    group?: string;
+};
+export type OrderDetail = {
+    id: string;
+    status?: number;
+    statusText?: string | null;
+    shippingDate?: string;
+    timeSlotDisplay?: string;
+    address?: string;
+    totals: {
+        total?: string;
+        totalEur?: string;
+        totalPaid?: string;
+        totalPaidEur?: string;
+        discount?: string;
+        discountEur?: string;
+        tip?: string;
+        tipEur?: string;
+    };
+    items: OrderItem[];
+    additionalOrders?: OrderDetail[];
+};

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "ebag",
+  "version": "0.0.2",
+  "description": "Unofficial CLI for interacting with ebag.bg using cookie-based auth.",
+  "main": "dist/lib/index.js",
+  "types": "dist/lib/index.d.ts",
+  "bin": {
+    "ebag": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "capture": "node scripts/capture.mjs",
+    "local-install": "npm run build && TARBALL=$(npm pack --silent) && npm i -g \"$TARBALL\"",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli/index.js",
+    "test:unit": "npm run build && node tests/format.test.mjs && node tests/cookie.test.mjs && node tests/slots.test.mjs && node tests/orders.test.mjs && node tests/search-cache.test.mjs",
+    "test:e2e": "npm run build && node tests/e2e.mjs",
+    "test": "npm run test:unit && npm run test:e2e"
+  },
+  "keywords": [
+    "ebag",
+    "ebag.bg",
+    "grocery",
+    "supermarket",
+    "shopping",
+    "delivery",
+    "cli",
+    "bulgaria",
+    "store"
+  ],
+  "license": "GPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nb/ebag.git"
+  },
+  "bugs": "https://github.com/nb/ebag/issues",
+  "homepage": "https://github.com/nb/ebag#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "playwright": "^1.57.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "commander": "^14.0.2"
+  }
+}