@ibnumardini/wilayah-indonesia/src/transform-data.js

Wilayah Indonesia - A CLI tool to manage and transform Indonesian administrative data.

const ObjectToCsv = require("objects-to-csv");

const { TO, TYPE } = require("./config/constant/transfrom-constant");

const { ObjectsToSQLInsert } = require("./helper/sql");
const { writeToFile, readFromFile } = require("./helper/file");
const { titleCase } = require("./helper/string");
const logger = require("./helper/logger");

const dataRawPath = "./data/raw";
const dataPath = "./data/transformed";

const getRawData = async (order, type) => {
  const file = await readFromFile(`${dataRawPath}/${order}-${type}.json`);

  if (!file) throw new Error(`${type} data not found`);

  return file;
};

const saveTransformedData = async ({ to, order, type, data }) => {
  const filePath = `./${dataPath}/${to}/${order}-${type}.${to}`;

  if (typeof data === "string") data = JSON.parse(data);

  switch (to) {
    case TO.CSV:
      const csv = new ObjectToCsv(data);
      data = await csv.toString();
      break;
    case TO.SQL:
      data = ObjectsToSQLInsert(type, data);
      break;
    case TO.JSON:
    default:
      data = JSON.stringify(data, null, 2);
  }

  writeToFile(filePath, data);

  logger.error(`Transformed ${type} data saved to ${filePath}`, true);
};

const transformProvinces = async ({ to }) => {
  const provinces = await getRawData(TYPE.PROVINCES.order, TYPE.PROVINCES.name);

  let transformedProvinces = provinces.map((province) => ({
    code: province.kode_bps,
    name: titleCase(province.nama_bps),
  }));

  saveTransformedData({
    to,
    order: TYPE.PROVINCES.order,
    type: TYPE.PROVINCES.name,
    data: transformedProvinces,
  });
};

const transformRegencies = async ({ to }) => {
  const regencies = await getRawData(TYPE.REGENCIES.order, TYPE.REGENCIES.name);

  let transformedRegencies = regencies.map((regency) => ({
    code: regency.kode_bps,
    name: titleCase(regency.nama_bps),
    province_code: regency.kode_bps.slice(0, 2),
  }));

  saveTransformedData({
    to,
    order: TYPE.REGENCIES.order,
    type: TYPE.REGENCIES.name,
    data: transformedRegencies,
  });
};

const transformDistricts = async ({ to }) => {
  const districts = await getRawData(TYPE.DISTRICTS.order, TYPE.DISTRICTS.name);

  let transformedDistricts = districts.map((district) => ({
    code: district.kode_bps,
    name: titleCase(district.nama_bps),
    regency_code: district.kode_bps.slice(0, 4),
  }));

  saveTransformedData({
    to,
    order: TYPE.DISTRICTS.order,
    type: TYPE.DISTRICTS.name,
    data: transformedDistricts,
  });
};

const transformSubdistricts = async ({ to }) => {
  const subdistricts = await getRawData(
    TYPE.SUBDISTRICTS.order,
    TYPE.SUBDISTRICTS.name
  );

  let transformedSubdistricts = subdistricts.map((subdistrict) => ({
    code: subdistrict.kode_bps,
    name: titleCase(subdistrict.nama_bps),
    district_code: subdistrict.kode_bps.slice(0, 7),
  }));

  saveTransformedData({
    to,
    order: TYPE.SUBDISTRICTS.order,
    type: TYPE.SUBDISTRICTS.name,
    data: transformedSubdistricts,
  });
};

const transformPostcodes = async ({ to }) => {
  const postcodes = await getRawData(TYPE.POSTCODES.order, TYPE.POSTCODES.name);

  let transformedPostcodes = postcodes.map((postCode, i) => ({
    code: i + 1,
    postcode: postCode.kode_pos,
    postname: titleCase(postCode.nama_pos),
    subdistrict_code: postCode.kode_bps,
  }));

  saveTransformedData({
    to,
    order: TYPE.POSTCODES.order,
    type: TYPE.POSTCODES.name,
    data: transformedPostcodes,
  });
};

const transformData = async ({ to }) => {
  try {
    await Promise.all([
      transformProvinces({ to }),
      transformRegencies({ to }),
      transformDistricts({ to }),
      transformSubdistricts({ to }),
      transformPostcodes({ to }),
    ]);
  } catch (error) {
    throw error;
  }
};

module.exports = transformData;