@terascope/data-mate 2.23.1 → 2.25.0

package/dist/src/function-configs/string/sql-utils.js

@@ -0,0 +1,321 @@
+import { isAsciiSql, sqlLiteral } from '../sql-helpers.js';
+import { re2Literal } from './sql-regex-utils.js';
+/**
+ * Helpers shared by the SQL expressions on the string function configs.
+*/
+/**
+ * `validator.isAlpha`'s `en-US` alphabet, as an RE2 pattern.
+ *
+ * Other locales use different letter sets, and several cannot be written as a simple class, so the
+ * functions using this handle only the default locale.
+*/
+export const ALPHA_LOCALES = '^[A-Za-z]+$';
+/** `validator.isAlphanumeric`'s `en-US` set. */
+export const ALPHANUMERIC_LOCALES = '^[0-9A-Za-z]+$';
+/** True when no locale was given, so `validator`'s `en-US` default applies. */
+export function defaultLocale(locale) {
+    return locale == null || locale === 'en-US';
+}
+/**
+ * `encodeURIComponent`, built from `url_encode` plus the five characters it over-escapes.
+ *
+ * `url_encode` percent-escapes `!`, `'`, `(`, `)` and `*`, which `encodeURIComponent` leaves alone.
+ * Unescaping them afterwards is safe: a literal `%` in the input is already `%25` by then, so a
+ * `%21` in the output can only come from a real `!`.
+*/
+export function encodeURIComponentSql(value) {
+    const unescape = [
+        ['%21', '!'], ['%27', '\'\''], ['%28', '('], ['%29', ')'], ['%2A', '*'],
+    ];
+    return unescape.reduce((inner, [escaped, literal]) => `replace(${inner}, '${escaped}', '${literal}')`, `url_encode(${value})`);
+}
+/**
+ * `validator.isHash`'s length table, copied from its source. The check is only `^[a-fA-F0-9]{N}$`.
+*/
+export const HASH_LENGTHS = {
+    md5: 32,
+    md4: 32,
+    sha1: 40,
+    sha256: 64,
+    sha384: 96,
+    sha512: 128,
+    ripemd128: 32,
+    ripemd160: 40,
+    tiger128: 32,
+    tiger160: 40,
+    tiger192: 48,
+    crc32: 8,
+    crc32b: 8,
+};
+/**
+ * `validator.isUUID`'s per-version patterns, copied from its source.
+ *
+ * The default, `all`, is not the union of the numbered versions: it accepts versions 1-8 plus the
+ * nil and max UUIDs, and still requires the `[89ab]` variant nibble. It is written out rather than
+ * derived. None of the patterns use lookaround or backreferences, so RE2 compiles all of them.
+*/
+const UUID_HEX = '[0-9a-fA-F]';
+const UUID_TAIL = `${UUID_HEX}{8}-${UUID_HEX}{4}`;
+export function uuidPattern(version) {
+    if (version == null || version === 'all') {
+        return `^(?:${UUID_TAIL}-[1-8]${UUID_HEX}{3}-[89abAB]${UUID_HEX}{3}-${UUID_HEX}{12}`
+            + '|00000000-0000-0000-0000-000000000000'
+            + '|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$';
+    }
+    if (version === 'nil')
+        return '^00000000-0000-0000-0000-000000000000$';
+    if (version === 'max')
+        return `^[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12}$`;
+    if (version === 'loose') {
+        return `^${UUID_TAIL}-${UUID_HEX}{4}-${UUID_HEX}{4}-${UUID_HEX}{12}$`;
+    }
+    if (typeof version === 'number' || typeof version === 'string') {
+        const digit = String(version);
+        if (/^[1-8]$/.test(digit)) {
+            return `^${UUID_TAIL}-${digit}${UUID_HEX}{3}-[89abAB]${UUID_HEX}{3}-${UUID_HEX}{12}$`;
+        }
+    }
+    return null;
+}
+/**
+ * lodash's test for which word splitter to use. The case converters run in SQL only when it does
+ * not match.
+ *
+ * `_.camelCase` and the other converters run `words(deburr(string).replace(/['’]/g, ''))`, and
+ * `words` picks one of two algorithms:
+ *
+ * ```js
+ * var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+ * var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+ * ```
+ *
+ * When `reHasUnicodeWord` does not match, the result is `string.match(reAsciiWord)`, which splits
+ * on ASCII punctuation only, and SQL reproduces that exactly. The other algorithm handles case
+ * transitions, digit/letter boundaries, acronyms like `XMLHttpRequest` and combining marks, and
+ * keeps the UDF.
+ *
+ * `deburr` does nothing to input this guard admits, which contains only `[a-zA-Z0-9 ]`.
+*/
+export const HAS_UNICODE_WORD = '[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]';
+/** The words of an ASCII-path string, as a SQL list. */
+function asciiWords(value) {
+    return `regexp_extract_all(${value}, '[a-zA-Z0-9]+')`;
+}
+/**
+ * A case conversion over the ASCII word list.
+ *
+ * `join` is the separator between words; `first` and `rest` say how each word is cased. An empty
+ * word list gives `''`, which is what `_.camelCase('')` and `_.camelCase('---')` return.
+*/
+export function caseConvertSql(value, options) {
+    const words = asciiWords(value);
+    const { join, first, rest } = options;
+    const tail = `list_transform(${words}[2:], lambda w : ${rest('w')})`;
+    return `CASE WHEN len(${words}) = 0 THEN ''`
+        + ` ELSE array_to_string(list_prepend(${first(`${words}[1]`)}, ${tail}), '${join}') END`;
+}
+/** `word[0].toUpperCase() + word.slice(1).toLowerCase()`, which is lodash's `capitalize`. */
+export function capitalizeSql(word) {
+    return `upper(substring(${word}, 1, 1)) || lower(substring(${word}, 2))`;
+}
+/**
+ * `_.upperFirst`: the first character uppercased and the rest left as is.
+ *
+ * This is not `capitalize`, which also lowercases the rest. `_.startCase` uses this one, which is
+ * why `startCase('HELLO WORLD')` is `'HELLO WORLD'` and not `'Hello World'`.
+*/
+export function upperFirstSql(word) {
+    return `upper(substring(${word}, 1, 1)) || substring(${word}, 2)`;
+}
+/**
+ * Base64 validation per RFC 4648 with padding, `validator.isBase64`'s default.
+ *
+ * ```js
+ * var base64WithPadding = /^[A-Za-z0-9+/]+={0,2}$/;
+ * if (str === '') return true;
+ * if (options.padding && str.length % 4 !== 0) return false;
+ * ```
+ *
+ * This intentionally does not reproduce `core-utils`' `isBase64`, which also requires a UTF-8 round
+ * trip to be lossless. `toString('utf8')` replaces every invalid byte with U+FFFD, so that check
+ * accepts only base64 of UTF-8 text and rejects most base64-encoded binary.
+*/
+export function isBase64Sql(value) {
+    return `(${value} = '' OR (length(${value}) % 4 = 0`
+        + ` AND regexp_matches(${value}, '^[A-Za-z0-9+/]+={0,2}$')))`;
+}
+/**
+ * `validator.isFQDN` with its default options, for ASCII input.
+ *
+ * The function has no TLD list, which is what makes it expressible in SQL. With the defaults
+ * (`require_tld`, no underscores, no trailing dot, no wildcard, no numeric TLD, max length
+ * enforced) the algorithm is:
+ *
+ * 1. at least two dot-separated parts;
+ * 2. the last part matches `/^([a-z…]{2,}|xn[a-z0-9-]{2,})$/i`, contains no whitespace and is not
+ *    all digits;
+ * 3. every part is 1-63 characters, matches `/^[a-z_0-9-]+$/i`, has no full-width character, and
+ *    neither starts nor ends with `-`; and with `allow_underscores` false, contains no `_`.
+ *
+ * Non-ASCII input keeps the UDF. `validator`'s character classes run to `\u{ffff}` and include a
+ * full-width exclusion, which is not worth reproducing.
+*/
+export function isFQDNSql(value, udf) {
+    const parts = `string_split(${value}, '.')`;
+    const tld = `${parts}[-1]`;
+    const badPart = `list_filter(${parts}, lambda p :`
+        + ' NOT regexp_matches(p, \'^[A-Za-z0-9](([A-Za-z0-9-]{0,61})[A-Za-z0-9])?$\'))';
+    // non-ASCII goes to the UDF rather than being answered false: `validator`'s classes run to
+    // \u{ffff}, so `exämple.com` is a valid domain to it
+    return `CASE WHEN NOT ${isAsciiSql(value)} THEN ${udf(value)} ELSE (`
+        + `len(${parts}) >= 2`
+        + ` AND regexp_matches(${tld}, '^([A-Za-z]{2,}|[xX][nN][A-Za-z0-9-]{2,})$')`
+        + ` AND len(${badPart}) = 0) END`;
+}
+/**
+ * A hash or byte encoding of a string in SQL, shared by `encode` and `createID`.
+ *
+ * Returns null for a combination DuckDB cannot express, which is what the callers' `applies` check.
+ * The results match `node:crypto` and `Buffer` byte for byte, including for empty, non-ASCII,
+ * astral and combining-mark input:
+ *
+ * - `md5`, `sha1` and `sha256` return a lowercase hex digest, matching
+ *   `createHash(...).digest('hex')`. There is no `sha512` or `sha384`.
+ * - A base64 digest is `to_base64(unhex(<digest>))`.
+ * - `Buffer.from(x).toString('hex')` is `lower(hex(encode(x)))`. `hex()` is uppercase, and
+ *   `encode()` is used because a VARCHAR-to-BLOB cast rejects non-ASCII.
+ * - `Buffer.from(x).toString('base64')` is `to_base64(encode(x))`.
+*/
+export const SQL_HASHES = ['md5', 'sha1', 'sha256'];
+export function hashSql(algo, digest, value) {
+    if (algo === 'hex')
+        return `lower(hex(encode(${value})))`;
+    if (algo === 'base64')
+        return `to_base64(encode(${value}))`;
+    if (!SQL_HASHES.includes(algo))
+        return null;
+    if (digest === 'hex')
+        return `${algo}(${value})`;
+    if (digest === 'base64')
+        return `to_base64(unhex(${algo}(${value})))`;
+    return null;
+}
+/** Whether `hashSql` has an expression for this pair, so an `applies` need not build it. */
+export function hasHashSql(algo, digest) {
+    if (typeof algo !== 'string')
+        return false;
+    if (digest != null && digest !== 'hex' && digest !== 'base64')
+        return false;
+    return hashSql(algo, digest ?? 'hex', 'x') != null;
+}
+/**
+ * Whether a value is a single code point (not a single UTF-16 code unit).
+ *
+ * `extract`'s marker mode compares `char === start` while iterating code points, so a
+ * multi-character marker never matches and an astral one matches as a unit.
+*/
+export function isOneCodePoint(value) {
+    return typeof value === 'string' && [...value].length === 1;
+}
+/**
+ * `extract`'s marker mode: the text between the first `start` and the first `end` after it.
+ *
+ * This mirrors `_subSlice`, which finds `start` and then collects characters until `end`. A second
+ * `start` before the `end` is content (`'<a<b>'` extracts `'a<b'`), an unterminated run yields
+ * null, and `'a|b|c'` with `|` for both markers extracts `'b'`.
+*/
+export function extractMarkerSql(value, start, end) {
+    const s = sqlLiteral(start);
+    const e = sqlLiteral(end);
+    const after = `substring(${value}, position(${s} IN ${value}) + 1)`;
+    return `CASE WHEN position(${s} IN ${value}) = 0 OR position(${e} IN ${after}) = 0 THEN NULL`
+        + ` ELSE substring(${after}, 1, position(${e} IN ${after}) - 1) END`;
+}
+/**
+ * `extract`'s marker mode with `global`: every extraction, as a list.
+ *
+ * The repeated scan is a non-greedy `(?s).*?` between the two escaped markers. `(?s)` is required
+ * because the scan collects newlines and RE2's `.` does not match one without it. For example,
+ * `'a|b|c|d'` gives `['b']` and `'<>'` gives `['']`.
+*/
+export function extractMarkerAllSql(value, start, end) {
+    const pattern = `${re2Literal(start)}((?s).*?)${re2Literal(end)}`;
+    return `regexp_extract_all(${value}, ${sqlLiteral(pattern)}, 1)`;
+}
+/**
+ * `extract`'s regex mode, built from what `matchAll` does.
+ *
+ * `matchAll` forces the `g` flag and, per match, collects every capture group if the pattern has
+ * any, or the whole match otherwise. `extract` then takes the first element, or the whole list
+ * under `global`. So the SQL is `regexp_extract` at group 0 or 1, and `regexp_extract_all` for the
+ * list.
+ *
+ * The no-match case needs care. `matchAll` returns null when nothing matched, and its loop also
+ * stops on an empty match, so a pattern whose first match is empty gives null, not `''`.
+ * `regexp_extract` returns `''` for both, which `nullif` maps to null. When extracting a group, the
+ * whole match is tested first, because a group can capture the empty string inside a non-empty
+ * match.
+*/
+export function extractRegexSql(value, pattern, group) {
+    const pat = sqlLiteral(pattern);
+    const whole = `nullif(regexp_extract(${value}, ${pat}), '')`;
+    if (group === 0)
+        return whole;
+    return `CASE WHEN ${whole} IS NULL THEN NULL`
+        + ` ELSE regexp_extract(${value}, ${pat}, ${group}) END`;
+}
+/** `extract`'s regex mode with `global`: every match, or every first capture group. */
+export function extractRegexAllSql(value, pattern, group) {
+    return `regexp_extract_all(${value}, ${sqlLiteral(pattern)}, ${group})`;
+}
+/**
+ * A list expression that returns NULL rather than `[]` when nothing matched.
+ *
+ * `extract` under `global` returns null for no match in both modes, never an empty list, while
+ * `regexp_extract_all` returns `[]`.
+*/
+export function emptyToNull(list) {
+    return `CASE WHEN len(${list}) = 0 THEN NULL ELSE ${list} END`;
+}
+/**
+ * `isPhoneNumberLike`: strip every non-digit and check that 7 to 20 digits remain. It does not use
+ * libphonenumber.
+ *
+ * ```
+ * const testValue = toString(input).trim().replace(/\D/g, '');
+ * return inNumberRange(testValue.length, { min: 7, max: 20, inclusive: true });
+ * ```
+ *
+ * `trim()` cannot change the answer because whitespace is not a digit. `\D` is `[^0-9]` in both
+ * engines, and the remaining digits are ASCII, so `length()` counting characters agrees with
+ * JavaScript counting code units.
+*/
+export function phoneNumberLikeSql(value) {
+    return `length(regexp_replace(${value}, '[^0-9]', '', 'g')) BETWEEN 7 AND 20`;
+}
+/**
+ * Shannon entropy without an aggregate: split into characters, count each distinct one, and sum the
+ * terms.
+ *
+ * `list_filter` over the distinct characters does the per-character counting. It is quadratic in
+ * the number of distinct characters, which for text is bounded by the alphabet rather than the
+ * string length. The result is exact.
+ *
+ * The JavaScript builds its frequency table over code points (`for (const char of input)`) but
+ * divides by `input.length`, which counts UTF-16 code units. The two differ only for astral input,
+ * so astral input keeps the UDF.
+*/
+export function shannonEntropySql(value) {
+    const chars = `string_split(${value}, '')`;
+    const counts = `list_transform(list_distinct(${chars}),`
+        + ` lambda c : len(list_filter(${chars}, lambda x : x = c)))`;
+    const total = `len(${chars})`;
+    const terms = `list_transform(${counts},`
+        + ` lambda n : -((n / ${total}) * ln(n / ${total}) / ln(2)))`;
+    // `+ 0` turns negative zero into zero: for a string with one distinct character the term is
+    // `-(1 * 0 / ln(2))` = `-0`, where the JavaScript gets `0`. Same approach as
+    // `withinIntegerRange`.
+    return `CASE WHEN ${total} = 0 THEN 0`
+        + ` ELSE list_reduce(${terms}, lambda a, b : a + b) + 0 END`;
+}
+//# sourceMappingURL=sql-utils.js.map

package/dist/src/function-configs/string/sql-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils.js","sourceRoot":"","sources":["../../../../src/function-configs/string/sql-utils.ts"],"names":[],"mappings":"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"}

package/dist/src/function-configs/string/sql-validator-utils.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Predicate rules from `core-utils` and `validator`, rewritten as RE2 patterns.
+ *
+ * `isEmail` and `isMACAddress` in `core-utils` do not call `validator`; they use their own, simpler
+ * patterns, which is what these reproduce.
+*/
+/**
+ * `core-utils`' own `isEmail` pattern, which is not `validator.isEmail`.
+ *
+ * ```
+ * const EmailRegex = /^[A-Z0-9._%+-@]{1,64}@(?:[A-Z0-9-]{1,63}\.){1,8}[A-Z]{2,63}$/i;
+ * export function isEmail(input) { return isString(input) && EmailRegex.test(input); }
+ * ```
+ *
+ * It has no lookaround or backreference, so RE2 compiles it.
+ *
+ * The `i` flag is expanded by hand rather than passed to DuckDB. Without the `u` flag JavaScript's
+ * `i` uses simple case folding, while RE2 uses full Unicode folding, so `[A-Z]` with `i` matches
+ * KELVIN SIGN and LATIN SMALL LETTER LONG S in RE2 but not in JavaScript. Writing `[A-Za-z]` avoids
+ * case folding entirely, so no guard or UDF fallback is needed.
+ *
+ * `+-@` is a range (U+002B to U+0040), not three literals, so it also admits `,`, `.`, `/`, the
+ * digits, `:`, `;`, `<`, `=`, `>` and `?`. It is copied as written, and RE2 reads the range the
+ * same way.
+*/
+export declare const EMAIL_SQL_PATTERN: string;
+/**
+ * `core-utils`' `macAddressDelimiters`, which is not `validator.isMACAddress`.
+ *
+ * There is one fixed regex per delimiter, and `'any'` tries each in turn, so no backreference is
+ * needed to keep the separators consistent. `space` uses `JS_WHITESPACE_CLASS` because its `\s` is
+ * JavaScript's.
+*/
+export declare const MAC_SQL_PATTERNS: Record<string, string>;
+/** An OR of `regexp_matches` over several patterns - `isMACAddress`'s `any`, and `isMIMEType`. */
+export declare function matchesAny(value: string, patterns: readonly string[]): string;
+export declare const MIME_SQL_PATTERNS: readonly string[];
+/**
+ * `validator.isISO31661Alpha2`'s 249 country codes, generated from its source.
+ *
+ * The function is a `Set` lookup on `str.toUpperCase()`. `core-utils` does not pass
+ * `userAssignedCodes`, so nothing else in it is reachable.
+ *
+ * Non-ASCII values keep the UDF. JavaScript's `toUpperCase` uses full case mapping and can change a
+ * string's length, so `'fi'` (LATIN SMALL LIGATURE FI) uppercases to `'FI'`, a real country code,
+ * where DuckDB's simple mapping leaves it unchanged.
+*/
+export declare const ISO_3166_ALPHA2: readonly string[];
+//# sourceMappingURL=sql-validator-utils.d.ts.map

package/dist/src/function-configs/string/sql-validator-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-validator-utils.d.ts","sourceRoot":"","sources":["../../../../src/function-configs/string/sql-validator-utils.ts"],"names":[],"mappings":"AAGA;;;;;EAKE;AACF;;;;;;;;;;;;;;;;;;EAkBE;AACF,eAAO,MAAM,iBAAiB,QACP,CAAC;AACxB;;;;;;EAME;AACF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMnD,CAAC;AACF,kGAAkG;AAClG,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAE7E;AAYD,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAO9C,CAAC;AACF;;;;;;;;;EASE;AACF,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EA0P5C,CAAC"}