@koda-sl/baker-cli 0.500.0 → 0.503.0

package/dist/chunk-CCEDZTP7.js

@@ -0,0 +1,391 @@
+import {
+  CUSTOMER_LIST_BATCH_ROWS,
+  CUSTOMER_LIST_KEYS,
+  IDENTIFYING_CUSTOMER_LIST_KEYS,
+  UNHASHED_CUSTOMER_LIST_KEYS,
+  customAudienceMembersSchema,
+  customerListBatchSchema
+} from "./chunk-VIPKDXGU.js";
+
+// src/commands/ads/meta/customer-list.ts
+import { createHash } from "crypto";
+import { parse } from "csv-parse/sync";
+import { isSupportedCountry, parsePhoneNumberFromString } from "libphonenumber-js";
+var DATE_ORDERS = ["DMY", "MDY"];
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function headerWords(cell) {
+  return cell.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+var HEADER_PATTERNS = [
+  [/^(e ?mail|email address|correo|correo electronico|mail)$/, "EMAIL"],
+  [/^(phone|phone number|mobile|mobile phone|telefono|movil|tel|celular|cell)$/, "PHONE"],
+  [/^(first name|firstname|fname|fn|given name|nombre)$/, "FN"],
+  [/^(last name|lastname|lname|ln|surname|family name|apellido|apellidos)$/, "LN"],
+  [/^(first initial|fi)$/, "FI"],
+  [/^(city|town|ct|ciudad|localidad)$/, "CT"],
+  [/^(state|province|region|st|provincia|estado)$/, "ST"],
+  [/^(zip|zip code|zipcode|postcode|post code|postal code|cp|codigo postal)$/, "ZIP"],
+  [/^(country|country code|pais)$/, "COUNTRY"],
+  [/^(dob|birthday|birth date|birthdate|date of birth|fecha de nacimiento|fecha nacimiento)$/, "DOB"],
+  [/^(doby|birth year|year of birth)$/, "DOBY"],
+  [/^(dobm|birth month)$/, "DOBM"],
+  [/^(dobd|birth day)$/, "DOBD"],
+  [/^(gen|gender|sex|genero|sexo)$/, "GEN"],
+  [/^(madid|idfa|aaid|gaid|advertising id|mobile advertiser id)$/, "MADID"],
+  [/^(extern id|external id|customer id|client id|crm id)$/, "EXTERN_ID"],
+  [/^(lookalike value|value)$/, "LOOKALIKE_VALUE"]
+];
+function headerKey(cell) {
+  const words = headerWords(cell);
+  const upper = cell.trim().toUpperCase();
+  if (CUSTOMER_LIST_KEYS.includes(upper)) {
+    return upper;
+  }
+  return HEADER_PATTERNS.find(([pattern]) => pattern.test(words))?.[1];
+}
+function lettersOnly(value) {
+  return value.normalize("NFC").toLowerCase().replace(/[^\p{L}]/gu, "");
+}
+function email(value) {
+  const normalized = value.trim().toLowerCase();
+  return /^[^@\s;,|]+@[^@\s;,|]+\.[^@\s;,|]+$/.test(normalized) ? normalized : void 0;
+}
+function country(value) {
+  const code = value.trim().toUpperCase();
+  return /^[A-Z]{2}$/.test(code) && isSupportedCountry(code) ? code : void 0;
+}
+function phone(value, rowCountry) {
+  const region = rowCountry ? rowCountry : void 0;
+  const parsed = parsePhoneNumberFromString(value.trim(), region);
+  return parsed?.isValid() ? parsed.number.replace(/^\+/, "") : void 0;
+}
+function zip(value, rowCountry) {
+  const compact = value.toLowerCase().replace(/\s+/g, "");
+  if (compact === "") return void 0;
+  const us = rowCountry === "US" || /^\d{5}-\d{4}$/.test(compact);
+  return us ? /^\d{5}/.exec(compact)?.[0] ?? void 0 : compact;
+}
+function gender(value) {
+  const first = value.trim().toLowerCase();
+  if (/^(m|male|man|hombre|masculino|h)$/.test(first)) return "m";
+  if (/^(f|female|woman|mujer|femenino)$/.test(first)) return "f";
+  return void 0;
+}
+var US_STATE_CODES = {
+  alabama: "al",
+  alaska: "ak",
+  arizona: "az",
+  arkansas: "ar",
+  california: "ca",
+  colorado: "co",
+  connecticut: "ct",
+  delaware: "de",
+  districtofcolumbia: "dc",
+  washingtondc: "dc",
+  florida: "fl",
+  georgia: "ga",
+  hawaii: "hi",
+  idaho: "id",
+  illinois: "il",
+  indiana: "in",
+  iowa: "ia",
+  kansas: "ks",
+  kentucky: "ky",
+  louisiana: "la",
+  maine: "me",
+  maryland: "md",
+  massachusetts: "ma",
+  michigan: "mi",
+  minnesota: "mn",
+  mississippi: "ms",
+  missouri: "mo",
+  montana: "mt",
+  nebraska: "ne",
+  nevada: "nv",
+  newhampshire: "nh",
+  newjersey: "nj",
+  newmexico: "nm",
+  newyork: "ny",
+  northcarolina: "nc",
+  northdakota: "nd",
+  ohio: "oh",
+  oklahoma: "ok",
+  oregon: "or",
+  pennsylvania: "pa",
+  rhodeisland: "ri",
+  southcarolina: "sc",
+  southdakota: "sd",
+  tennessee: "tn",
+  texas: "tx",
+  utah: "ut",
+  vermont: "vt",
+  virginia: "va",
+  washington: "wa",
+  westvirginia: "wv",
+  wisconsin: "wi",
+  wyoming: "wy",
+  puertorico: "pr",
+  guam: "gu",
+  americansamoa: "as",
+  virginislands: "vi",
+  usvirginislands: "vi",
+  northernmarianaislands: "mp"
+};
+var US_STATE_ABBREVIATIONS = new Set(Object.values(US_STATE_CODES));
+function state(value, rowCountry) {
+  const letters = lettersOnly(value);
+  if (letters === "") return void 0;
+  if (rowCountry === "US") {
+    return US_STATE_CODES[letters] ?? (US_STATE_ABBREVIATIONS.has(letters) ? letters : void 0);
+  }
+  return (rowCountry === void 0 ? US_STATE_CODES[letters] : void 0) ?? letters;
+}
+function datePart(value, length, max) {
+  const digits = value.trim();
+  if (!/^\d{1,4}$/.test(digits)) return void 0;
+  const n = Number(digits);
+  if (length === 4) return digits.length === 4 && n >= 1900 && n <= max ? digits : void 0;
+  return n >= 1 && n <= max ? String(n).padStart(2, "0") : void 0;
+}
+var SLASHED_DATE = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{4})$/;
+function dateOrderOf(values, explicit) {
+  if (explicit) return explicit;
+  let dayFirst = false;
+  let monthFirst = false;
+  let ambiguous = false;
+  for (const value of values) {
+    const match = SLASHED_DATE.exec(value.trim());
+    if (!match) continue;
+    const [first, second] = [Number(match[1]), Number(match[2])];
+    dayFirst ||= first > 12;
+    monthFirst ||= second > 12;
+    ambiguous ||= first <= 12 && second <= 12 && first !== second;
+  }
+  if (dayFirst && monthFirst) {
+    throw new Error(
+      "this file writes birthdays both day-first and month-first \u2014 make them one order, or pass --date-format DMY|MDY for the order most use"
+    );
+  }
+  if (dayFirst) return "DMY";
+  if (monthFirst) return "MDY";
+  if (ambiguous) {
+    throw new Error(
+      "this file's birthdays (like 03/07/1990) can be read day-first or month-first \u2014 pass --date-format DMY (day/month/year) or MDY (month/day/year)"
+    );
+  }
+  return void 0;
+}
+function dateOfBirth(value, order) {
+  const text = value.trim();
+  const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})/.exec(text);
+  const slashed = SLASHED_DATE.exec(text);
+  const parts = iso ? [iso[1], iso[2], iso[3]] : slashed ? order === "MDY" ? [slashed[3], slashed[1], slashed[2]] : [slashed[3], slashed[2], slashed[1]] : void 0;
+  if (!parts) return void 0;
+  const year = datePart(parts[0] ?? "", 4, (/* @__PURE__ */ new Date()).getUTCFullYear());
+  const month = datePart(parts[1] ?? "", 2, 12);
+  const day = datePart(parts[2] ?? "", 2, 31);
+  return year && month && day ? [year, month, day] : void 0;
+}
+function decimalMarkShown(value) {
+  const cleaned = value.replace(/[^\d.,]/g, "");
+  const lastDot = cleaned.lastIndexOf(".");
+  const lastComma = cleaned.lastIndexOf(",");
+  if (lastDot >= 0 && lastComma >= 0) return lastDot > lastComma ? "." : ",";
+  const mark = lastDot >= 0 ? "." : lastComma >= 0 ? "," : void 0;
+  if (mark === void 0) return void 0;
+  if (cleaned.split(mark).length > 2) return mark === "." ? "," : ".";
+  return /^\d{3}$/.test(cleaned.slice(cleaned.indexOf(mark) + 1)) ? void 0 : mark;
+}
+function decimalMarkOf(values) {
+  for (const value of values) {
+    const mark = decimalMarkShown(value);
+    if (mark) return mark;
+  }
+  return void 0;
+}
+function numericValue(value, fileMark) {
+  const cleaned = value.replace(/[^\d.,-]/g, "");
+  const mark = decimalMarkShown(cleaned) ?? fileMark;
+  if (mark === void 0 && /[.,]/.test(cleaned)) return void 0;
+  const thousands = mark === "," ? "." : ",";
+  const plain = cleaned.split(thousands).join("").replace(",", ".");
+  const n = Number(plain);
+  return plain !== "" && Number.isFinite(n) && n >= 0 ? String(n) : void 0;
+}
+function normalizedCell(key, value, rowCountry, conventions) {
+  switch (key) {
+    case "EMAIL":
+      return email(value);
+    case "PHONE":
+      return phone(value, rowCountry);
+    case "FN":
+    case "LN":
+    case "CT":
+      return lettersOnly(value) || void 0;
+    case "FI":
+      return lettersOnly(value).slice(0, 1) || void 0;
+    case "ST":
+      return state(value, rowCountry);
+    case "ZIP":
+      return zip(value, rowCountry);
+    case "COUNTRY":
+      return country(value)?.toLowerCase();
+    case "DOBY":
+      return datePart(value, 4, (/* @__PURE__ */ new Date()).getUTCFullYear());
+    case "DOBM":
+      return datePart(value, 2, 12);
+    case "DOBD":
+      return datePart(value, 2, 31);
+    case "GEN":
+      return gender(value);
+    case "MADID":
+      return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value.trim().toLowerCase()) ? value.trim().toLowerCase() : void 0;
+    case "EXTERN_ID":
+      return value.trim() || void 0;
+    case "LOOKALIKE_VALUE":
+      return numericValue(value, conventions.decimalMark);
+    default:
+      return void 0;
+  }
+}
+function planColumns(firstRow, options) {
+  if (options.columns) {
+    const plan2 = options.columns.map((name, source) => {
+      const key = headerKey(name);
+      if (!key)
+        throw new Error(`--columns: "${name}" is not a column Meta matches on (${CUSTOMER_LIST_KEYS.join(", ")})`);
+      return { source, key };
+    });
+    return { plan: plan2, ignored: [], hasHeader: false };
+  }
+  const valueHeader = options.valueColumn ? headerWords(options.valueColumn) : void 0;
+  const plan = [];
+  const ignored = [];
+  firstRow.forEach((cell, source) => {
+    const named = valueHeader !== void 0 && headerWords(cell) === valueHeader;
+    const key = named ? "LOOKALIKE_VALUE" : headerKey(cell);
+    if (key && (key !== "LOOKALIKE_VALUE" || named) && !plan.some((entry) => entry.key === key)) {
+      plan.push({ source, key });
+    } else if (cell.trim() !== "") {
+      ignored.push(cell.trim());
+    }
+  });
+  if (valueHeader && !plan.some((entry) => entry.key === "LOOKALIKE_VALUE")) {
+    throw new Error(`--value-column "${options.valueColumn}" is not a column of this file`);
+  }
+  return { plan, ignored, hasHeader: true };
+}
+function schemaOf(plan) {
+  return plan.flatMap((entry) => entry.key === "DOB" ? ["DOBY", "DOBM", "DOBD"] : [entry.key]);
+}
+function hashed(key, normalized) {
+  return UNHASHED_CUSTOMER_LIST_KEYS.has(key) ? normalized : sha256(normalized);
+}
+function rowCountryOf(row, plan, defaultCountry) {
+  const column = plan.find((entry) => entry.key === "COUNTRY");
+  return (column ? country(row[column.source] ?? "") : void 0) ?? defaultCountry;
+}
+function countUnreadable(unreadable, key) {
+  unreadable[key] = (unreadable[key] ?? 0) + 1;
+}
+function columnCells(entry, raw, rowCountry, unreadable, conventions) {
+  const blank = raw.trim() === "";
+  if (entry.key === "DOB") {
+    const parts = blank ? void 0 : dateOfBirth(raw, conventions.dateOrder);
+    if (!blank && !parts) countUnreadable(unreadable, "DOBY");
+    return [
+      ["DOBY", parts?.[0] ?? ""],
+      ["DOBM", parts?.[1] ?? ""],
+      ["DOBD", parts?.[2] ?? ""]
+    ];
+  }
+  if (blank) return [[entry.key, ""]];
+  const normalized = normalizedCell(entry.key, raw, rowCountry, conventions);
+  if (normalized === void 0) countUnreadable(unreadable, entry.key);
+  return [[entry.key, normalized ?? ""]];
+}
+function delimiterOf(content) {
+  const firstLine = content.replace(/^\uFEFF/, "").split(/\r?\n/).find((line) => line.trim() !== "") ?? "";
+  const unquoted = firstLine.replace(/"[^"]*"/g, "");
+  const count = (mark) => unquoted.split(mark).length - 1;
+  const most = Math.max(count("	"), count(";"), count(","));
+  return most === 0 ? "," : ["	", ";", ","].find((mark) => count(mark) === most) ?? ",";
+}
+function customerListFromFile(content, options) {
+  const delimiter = delimiterOf(content);
+  const table = parse(content, {
+    bom: true,
+    skip_empty_lines: true,
+    relax_column_count: true,
+    trim: true,
+    delimiter
+  });
+  const { plan, ignored, hasHeader } = planColumns(table[0] ?? [], options);
+  const schema = schemaOf(plan);
+  if (!schema.some((key) => IDENTIFYING_CUSTOMER_LIST_KEYS.includes(key))) {
+    throw new Error(
+      "this file has no column Meta can match people on \u2014 it needs one of email, phone, mobile advertiser id or your own customer id (name the columns with --columns for a file without a header)"
+    );
+  }
+  const defaultCountry = options.defaultCountry ? country(options.defaultCountry) : void 0;
+  const body = table.slice(hasHeader ? 1 : 0);
+  const columnValues = (key) => {
+    const column = plan.find((entry) => entry.key === key);
+    return column ? body.map((row) => row[column.source] ?? "") : [];
+  };
+  const conventions = {
+    dateOrder: dateOrderOf(columnValues("DOB"), options.dateFormat),
+    decimalMark: decimalMarkOf(columnValues("LOOKALIKE_VALUE"))
+  };
+  const valueBased = schema.includes("LOOKALIKE_VALUE");
+  const unreadable = {};
+  const rows = [];
+  let skippedRows = 0;
+  for (const row of body) {
+    const rowCountry = rowCountryOf(row, plan, defaultCountry);
+    const cells = plan.flatMap(
+      (entry) => columnCells(entry, row[entry.source] ?? "", rowCountry, unreadable, conventions)
+    );
+    const identified = cells.some(([key, value]) => value !== "" && IDENTIFYING_CUSTOMER_LIST_KEYS.includes(key));
+    const valued = !valueBased || cells.some(([key, value]) => key === "LOOKALIKE_VALUE" && value !== "");
+    if (!identified || !valued) {
+      skippedRows++;
+      continue;
+    }
+    rows.push(cells.map(([key, value]) => value === "" ? "" : hashed(key, value)));
+  }
+  return { schema, rows, skippedRows, unreadable, ignoredColumns: ignored };
+}
+function customerListBatches(rows) {
+  const out = [];
+  for (let at = 0; at < rows.length; at += CUSTOMER_LIST_BATCH_ROWS)
+    out.push(rows.slice(at, at + CUSTOMER_LIST_BATCH_ROWS));
+  return out;
+}
+function customerListUploadRefusal(audienceId, action, list) {
+  const batches = customerListBatches(list.rows);
+  for (const rows of batches) {
+    const batch = customerListBatchSchema.safeParse({ schema: list.schema, rows });
+    if (!batch.success) return batch.error.issues[0]?.message;
+  }
+  const change = customAudienceMembersSchema.safeParse({
+    audience_id: audienceId,
+    action,
+    schema: list.schema,
+    batches: batches.map((rows, index) => ({ fileId: `local-${index}`, rows: rows.length }))
+  });
+  if (change.success) return void 0;
+  const issue = change.error.issues[0];
+  return issue?.path[0] === "audience_id" ? `${audienceId} is not a custom audience id or a meta_temp_* ref from this chat` : issue?.message;
+}
+
+export {
+  DATE_ORDERS,
+  decimalMarkShown,
+  customerListFromFile,
+  customerListBatches,
+  customerListUploadRefusal
+};
+//# sourceMappingURL=chunk-CCEDZTP7.js.map