FROM apify/actor-node:16

COPY package.json ./

RUN npm --quiet set progress=false \
  && npm install --only=prod --no-optional

COPY . ./

Dockerfile

Scrapes products titles, prices, images and availability. Does NOT scrape product details. Uses Crawlee (Apify v3).

If set to true, the actor will not store the results in the default dataset. Useful when using alternative storage, like own database

Advanced options, use only if you know what you're doing.

Don't store in dataset

If set, actor will store normalized data in Postgres database in PG_DATA_TABLE and PG_DATA_PRICE_TABLE tables

Postgres connection string for normalized data

Table name for storing price, original price, stock status, ...

Postgres table name for price data

Table name for storing product name, url, image, ...

Postgres table name for product data

Mode

Axit (axit.cz) scraper

INPUT_SCHEMA.json

axit-axit-cz-scraper

apify.json

import { Actor } from "apify3";
import { CheerioCrawler, createCheerioRouter } from "crawlee";
import { gotScraping } from "got-scraping";
import cheerio from "cheerio";
import { init, save, toNumberOrNull } from "./_utils/common.js";

var LABEL;

(function (LABEL) {
  LABEL["INDEX"] = "INDEX";
  LABEL["PRODUCTS"] = "PRODUCTS";
})(LABEL || (LABEL = {}));
var MODE;

(function (MODE) {
  MODE["TEST"] = "TEST";
  MODE["FULL"] = "FULL";
})(MODE || (MODE = {}));

async function enqueueInitial(type, crawler) {
  if (type === MODE.FULL) {
    await crawler.addRequests([
      {
        url: `https://www.axit.cz`,
        userData: { label: LABEL.INDEX },
      },
    ]);
  } else if (type === MODE.TEST) {
    const requests = [`shimano`, `crankbrothers`].map((brand) => ({
      url: `https://www.axit.cz/vyrobci/${brand}`,
      userData: { label: LABEL.PRODUCTS, brand },
    }));
    await crawler.addRequests(requests);
  }
}

async function parseAndSaveProducts($) {
  const products = [];
  const $products = $(`.products .item`);
  $products.each(async (i, el) => {
    const relUrl = $(`a.image`, el).attr(`href`);
    const url = `https://www.axit.cz${relUrl}`;

    // id = relUrl.match(/\/d(\d\w+)_/)[1] // e.g. /d123456_... -> 123456 // BEWARE: not every item has id in url
    const pid = $(el).find(`.compare`).attr(`id`).replace(`compare_add_`, ``); // e.g. compare_add_172702 -> 172702

    const name = $(`a.image`, el).attr(`title`);

    const priceRaw = $(el).find(`.price`).text().trim(); // `640,00 Kč`
    const price = priceRaw.split(`,`)[0].replace(/\D/g, ``); // 2 999,00 Kč -> 2999

    const priceOrigRaw = $(el).find(`.original-price`).text().trim();
    const priceOrig = priceOrigRaw.replace(/\D/g, ``); // 3 990 Kč -> 3990
    const imgRel = $(`a.image img`, el).attr(`src`);
    const img = `https://www.axit.cz${imgRel}`;

    const inStock = $(el).find(`.availability.instock`).length > 0;

    const product = {
      pid,
      name,
      url,
      img,
      inStock,
      currentPrice: toNumberOrNull(price),
      originalPrice: toNumberOrNull(priceOrig),
      currency: `CZK`,
    };
    products.push(product);
  });
  await save(products);
}

async function fetchProducts({ brandId, PHPSESSID, csrfToken, page }) {
  const ajaxRes = await gotScraping({
    url: `https://www.axit.cz/ajax/products_content.php`,
    method: `POST`,
    headers: {
      "Content-Type": `application/x-www-form-urlencoded; charset=UTF-8`,
      "x-requested-with": `XMLHttpRequest`,
      referer: `https://www.axit.cz/vyrobci/shimano/`, // TODO
      cookie: `PHPSESSID=${PHPSESSID}`,
      origin: `https://www.axit.cz`,
      pragma: `no-cache`,
      "cache-control": `no-cache`,
      authority: `www.axit.cz`,
      accept: `*/*`,
      "accept-language": `en-US,en;q=0.9,cs;q=0.8,sk;q=0.7`,
    },
    form: {
      list_brand: brandId,
      cpage: page, // = page number
      epage: 80, // = per page
      razeni: `p_name`, // = sort by name
      CSRFtoken: csrfToken,

      nextpage: 0,
      categoryid: 0,
      subcategoryid: 0,
      subsubcategoryid: 0,
      subsubsubcategoryid: 0,
      cphrase: ``,
      list_label: 0,
      base_products: ``,
      // eprice: 0 - 13150,
      // eprice2: 0 - 13150,
      initialize: 1,
    },
  });
  const ajaxBody = ajaxRes.body; // kinda weird HTML https://share.cleanshot.com/pFGlpy
  return cheerio.load(ajaxBody);
}

const router = createCheerioRouter();

router.addHandler(LABEL.INDEX, async function ({ $, crawler }) {
  const requests = [];
  $(`#header .maker a[href^="/vyrobci"]`).each((i, el) => {
    // /vyrobci/shimano/ -> shimano
    const slug = $(el).attr(`href`).replace(`/vyrobci/`, ``).replace(/\/$/, ``); // replace trailing slash
    requests.push({
      url: `https://www.axit.cz/vyrobci/${slug}/#razeni=p_name`,
      userData: { label: LABEL.PRODUCTS, brand: slug },
    });
  });
  await crawler.addRequests(requests);
});
router.addHandler(LABEL.PRODUCTS, async function ({ request, response, $ }) {
  const { userData } = request;

  const brandId = $(`input[name="list_brand"]`).attr(`value`);
  if (!brandId) {
    console.log(
      `No brandId found for ${userData.brand} – that does not mean anything, just FYI`
    );
    console.log(`Url: ${request.url}`);
    return;
  }

  const setCookieResHeader = response.headers[`set-cookie`][0]; // PHPSESSID=abc133; expires=Mon, 05-Sep-2022 12:31:52 GMT; Max-Age=172800; path=/; secure
  const PHPSESSID = setCookieResHeader.split(`;`)[0].split(`=`)[1]; // abc133
  if (!PHPSESSID) throw new Error(`PHPSESSID not found`);

  const csrfToken = $(`input[name="CSRFtoken"]`).attr(`value`);
  if (!csrfToken) throw new Error(`CSRFtoken not found`);

  // Pagination – Axit does not show the last page, only that there are more pages
  let hasMorePages = true;
  let page = 0;
  while (hasMorePages) {
    const $ajax = await fetchProducts({
      brandId,
      PHPSESSID,
      csrfToken,
      page,
    });
    console.log(`fetchProducts`, {
      brand: userData.brand,
      brandId,
      page,
      products: $ajax(`.products .item`).length,
    });
    await parseAndSaveProducts($ajax);
    if ($ajax(`.pagination [rel=next]`).length) {
      page++;
    } else {
      hasMorePages = false;
    }
  }
});

void Actor.main(async () => {
  const input = await Actor.getInput();
  const { mode = MODE.FULL, ...rest } = input ?? {};
  await init({ actorNameOverride: `axit-cz` }, rest);
  const crawler = new CheerioCrawler({ requestHandler: router });
  await enqueueInitial(mode, crawler);
  await crawler.run();
});


main.js

package.json

.actor/actor.json

.actor/logo.png

import { createHash } from 'crypto'
import os from "os"
import path from "path"
// eslint-disable-next-line @apify/apify-actor/no-forbidden-node-internals
import fs from "fs"
import pg from "pg"
import pgConnectionString from 'pg-connection-string'
import { config } from 'dotenv'
import findConfig from "find-config"
import { Client as ElasticClient } from "@elastic/elasticsearch"
import filenamify from 'filenamify'
import { Dataset } from 'crawlee'

config({ path: findConfig(`.env`) })

const elasticIndexName = `actors-monorepo-shops`

const globalLogsProps = {
  __NODE_STARTED: new Date().toISOString(),
}

let actorName
let pgClient
let pgClientNormalized
let elasticClient
export async function init ({ actorNameOverride }, restInput) {
  parseEnvFromInput(restInput)

  if (os.platform() === `darwin`) {
    const filePath = process.argv[1] // ~/Projects/apify-actors-monorepo/actors/foo.ts
    const basename = path.basename(filePath) // foo.ts
    actorName = actorNameOverride ?? basename.split(`.`)[0] // foo
    const gitBranch = fs.readFileSync(path.join(process.cwd(), `..`, `.git/HEAD`), `utf8`)
      .split(` `)[1]
      .trim()
      .replace(`refs/heads/`, ``)
    const gitCommit = fs.readFileSync(path.join(process.cwd(), `..`, `.git/refs/heads/${gitBranch}`), `utf8`)
    const gitCommitShort = gitCommit.substring(0, 7)
    globalLogsProps.__GIT_COMMIT = gitCommitShort
  }

  if (process.env.APIFY_IS_AT_HOME) {
    actorName = actorNameOverride ?? process.env.APIFY_ACTOR_ID // Name would be better, but it's not in ENV
  }

  /* ELASTIC */
  /* ======= */
  if (process.env.ELASTIC_CLOUD_ID) {
    elasticClient = new ElasticClient({
      cloud: { id: process.env.ELASTIC_CLOUD_ID },
      auth: { apiKey: process.env.ELASTIC_CLOUD_API_KEY },
    })

    // const mapping = await elasticClient.indices.getMapping({ index: actorName })

    // eslint-disable-next-line no-inner-declarations
    async function enforceIndexMapping () {
      const doesIndexExist = await elasticClient.indices.exists({ index: elasticIndexName })
      if (!doesIndexExist) await elasticClient.indices.create({ index: elasticIndexName })
      await elasticClient.indices.putMapping({
        index: elasticIndexName,
        body: {
          properties: {
            _discount: { type: `float` },
            originalPrice: { type: `float` },
            currentPrice: { type: `float` },
          },
        },
      })
    }

    try {
      await enforceIndexMapping()
    } catch (err) {
      if (err.message.includes(`cannot be changed from type`)) {
        console.log(`Elastic index ${elasticIndexName} already exists with incorrect mappings. As existing mapping cannot be changed, index will be deleted and recreated.`)
        await elasticClient.indices.delete({ index: elasticIndexName })
        await enforceIndexMapping()
      }
    }
  }

  /* POSTGRESQL */
  /* ========== */
  if (process.env.PG_CONNECTION_STRING) {
    const pgConfig = pgConnectionString(process.env.PG_CONNECTION_STRING)
    // const pgPool = new pg.Pool(pgConfig)

    pgClient = new pg.Client(pgConfig)
    await pgClient.connect()

    // Check if table exists and have proper columns
    const { rows: tables } = await pgClient.query(`
    SELECT table_name
    FROM information_schema.tables
    WHERE table_schema = 'public'
  `)

    // eslint-disable-next-line camelcase
    const tableExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_TABLE)
    if (!tableExists) {
      throw new Error(`Table ${process.env.PG_DATA_TABLE} does not exist in database ${pgConfig.database}`)
    }

  // TODO: Handle pgClient closing
  }

  if (process.env.PG_CONNECTION_STRING_NORMALIZED) {
    const pgConfig = pgConnectionString(process.env.PG_CONNECTION_STRING_NORMALIZED)

    pgClientNormalized = new pg.Client(pgConfig)
    await pgClientNormalized.connect()

    // Check if table exists and have proper columns
    const { rows: tables } = await pgClientNormalized.query(`
    SELECT table_name
    FROM information_schema.tables
    WHERE table_schema = 'public'
  `)

    // eslint-disable-next-line camelcase
    const tableMainExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_TABLE)
    // eslint-disable-next-line camelcase
    const tablePricesExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_PRICE_TABLE)
    if (!tableMainExists) throw new Error(`Table ${process.env.PG_DATA_TABLE} does not exist in database ${pgConfig.database}`)
    if (!tablePricesExists) throw new Error(`Table ${process.env.PG_DATA_PRICE_TABLE} does not exist in database ${pgConfig.database}`)

  // TODO: Handle pgClient closing
  }
}

// inspired by @drobnikj
// TODO: Similar, but less obfuscated for easier debugging
export const createUniqueKeyFromUrl = (url) => {
  const hash = createHash(`sha256`)
  const cleanUrl = url.split(`://`)[1] // Remove protocol
  hash.update(cleanUrl)
  return hash.digest(`hex`)
}

/**
 *
 * @param {Date} datetime
 * @return {Promise<void>}
 */
export const sleepUntil = async (datetime) => {
  const now = new Date()
  const difference = datetime - now
  if (difference > 0) {
    return new Promise((resolve) => {
      setTimeout(resolve, difference)
    })
  }
  return Promise.resolve()
}

export function parsePrice (string) {
  let amount, currency
  const noText = string.replace(/[^\d,.]/g, ``)
  const decimals = noText.match(/([,.])(\d{2})$/)
  if (decimals) {
    const decimalSeparator = decimals[1]
    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
    const decimalAmount = decimals[2]
    amount = parseInt(noText.split(decimalSeparator)[0])
  } {
    const justNumbers = noText.replace(/[,.]/g, ``)
    amount = parseInt(justNumbers)
  }
  return { amount, currency }
}

export function toNumberOrNull (str) {
  // TODO: Handle better, but only after adding test
  if (str === undefined) return null
  if (str === null) return null
  if (str === ``) return null
  const num = Number(str)
  if (Number.isNaN(num)) return null
  return num
}

export async function save (objs) {
  if (!Array.isArray(objs)) objs = [objs]
  if (objs.length === 0) return

  const objsExtended = objs.map((obj) => {
    const objExtended = {
      ...obj,
      actorName,
      ...globalLogsProps,
      // __NODE_VERSION: global.process.versions.node,
      // __NODE_UPTIME: global.process.uptime().toFixed(2), // seconds, 2 decimals
    }
    // if run on Apify
    if (process.env.APIFY_IS_AT_HOME) {
      objExtended.__APIFY_ACTOR_ID = process.env.APIFY_ACTOR_ID
      objExtended.__APIFY_ACTOR_RUN_ID = process.env.APIFY_ACTOR_RUN_ID
      objExtended.__APIFY_ACTOR_BUILD_ID = process.env.APIFY_ACTOR_BUILD_ID
      objExtended.__APIFY_ACTOR_BUILD_NUMBER = process.env.APIFY_ACTOR_BUILD_NUMBER
      objExtended.__APIFY_ACTOR_TASK_ID = process.env.APIFY_ACTOR_TASK_ID
      if (!process.env.APIFY_DONT_STORE_IN_DATASET) void Dataset.pushData(obj)
    }
    return objExtended
  })
  // if runs on local machine (MacOS)
  if (os.platform() === `darwin`) {
    const cwd = process.cwd() // ~/Projects/apify-actors-monorepo/actors
    const storageDir = path.join(cwd, `${actorName}.storage`) // ~/Projects/apify-actors-monorepo/actors/foo.storage
    if (!fs.existsSync(storageDir)) fs.mkdirSync(storageDir)
    const dataDir = path.join(storageDir, `data`) // ~/Projects/apify-actors-monorepo/actors/foo.storage/data
    if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir)
    for (const objExtended of objsExtended) {
      const id = objExtended.id ?? objExtended.pid // ?? uuidv4()
      const fileName = `${filenamify(id)}.json`
      const dataFilePath = path.join(dataDir, fileName) // ~/Projects/apify-actors-monorepo/actors/foo.storage/data/foo.json
      fs.writeFileSync(dataFilePath, JSON.stringify(objExtended, null, 2))
    }
  }

  if (pgClient) {
    const objsPg = objs.map((obj) => ({
      ...obj,
      // TODO: This is becoming not nice, and not clear
      shop: actorName,
      scrapedAt: new Date().toISOString().split(`T`)[0],
    }))

    const columns = getColumns(objsPg)
    const values = getValues(objsPg)
    const queryString = `
        INSERT INTO public."${process.env.PG_DATA_TABLE}" (${columns})
        VALUES (${values})
    `
    try {
      const { rowCount } = await pgClient.query(queryString)
      console.log(`[save] saved to database: ${JSON.stringify(rowCount)}`)
    } catch (err) {
      if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
      else throw err
    }
  }

  // Only make sense for HlidacShopu
  if (pgClientNormalized) {
    const objsPgData = objs.map((obj) => ({
      shop: actorName,
      pid: obj.pid,
      name: obj.name,
      url: obj.url,
      img: obj.img,
    }))

    const objsPgDataPrice = objs.map((obj) => ({
      shop: actorName,
      pid: obj.pid,
      scrapedAt: new Date().toISOString().split(`T`)[0],
      currentPrice: obj.currentPrice,
      originalPrice: obj.originalPrice,
      inStock: obj.inStock,
    }))

    const queryString = `
        INSERT INTO public."${process.env.PG_DATA_TABLE}" (${getColumns(objsPgData)})
        VALUES (${getValues(objsPgData)})
        ON CONFLICT DO NOTHING
    `
    try {
      const { rowCount } = await pgClientNormalized.query(queryString)
      console.log(`[save] saved to database (data): ${JSON.stringify(rowCount)}`)
    } catch (err) {
      if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
      else throw err
    }

    const queryStringPrice = `
        INSERT INTO public."${process.env.PG_DATA_PRICE_TABLE}" (${getColumns(objsPgDataPrice)})
        VALUES (${getValues(objsPgDataPrice)})
        ON CONFLICT DO NOTHING
    `
    try {
      const { rowCount } = await pgClientNormalized.query(queryStringPrice)
      console.log(`[save] saved to database (price): ${JSON.stringify(rowCount)}`)
    } catch (err) {
      if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
      else throw err
    }
  }

  if (elasticClient) {
    // .index creates or updates the document
    // .create creates a new document if it doesn't exist, 409 if it does
    // try {
    //   const res = await elasticClient.index({
    //     index: `actors-monorepo-shops`, // TODO: Consider using actorName
    //     id, // foo-bar
    //     document: objExtended, // {...}
    //   })
    // } catch (err) {
    //   // https://discuss.elastic.co/t/elasticsearch-503-ok-false-message-the-requested-deployment-is-currently-unavailable/200583
    //   if (err.message.includes(`requested resource is currently unavailable`)) console.log(`Elasticsearch is unavailable, skipping, but not aborting`)
    //   else throw err
    // }
  }
}

function getColumns (objs) {
  return Object.keys(objs[0]).map((key) => `"${key}"`).join(`, `)
}

function getValues (objs) {
  return objs.map(objPg => Object.values(objPg).map((value) => {
    // escape strings to prevent SQL injection
    if (typeof value === `string`) return `'${value.replace(/'/g, `''`)}'`
    // convert to DB specific null
    if (typeof value === `undefined` || value === null) return `NULL`
    return value
  }).join(`, `)).join(`), (`)
}

export function parseEnvFromInput (input) {
  const env = {}
  for (const key in input) {
    if (key === key.toUpperCase()) env[key] = input[key]
  }
  console.log(`[parseEnvFromInput] ${JSON.stringify(env)}`)
  Object.assign(process.env, env)
}


Axit (axit.cz) scraper

Output example

Where next?