@powersync/service-sync-rules 0.17.10

package/dist/sql_functions.js

@@ -0,0 +1,773 @@
+import { JSONBig } from '@powersync/service-jsonbig';
+import { SQLITE_FALSE, SQLITE_TRUE, sqliteBool } from './sql_support.js';
+import { jsonValueToSqlite } from './utils.js';
+// Declares @syncpoint/wkx module
+// This allows for consumers of this lib to resolve types correctly
+/// <reference types="./wkx.d.ts" />
+import wkx from '@syncpoint/wkx';
+import { ExpressionType, TYPE_INTEGER } from './ExpressionType.js';
+export const BASIC_OPERATORS = new Set([
+    '=',
+    '!=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '||',
+    'AND',
+    'OR',
+    'IS',
+    'IS NOT'
+]);
+const upper = {
+    call(value) {
+        const text = castAsText(value);
+        return text?.toUpperCase() ?? null;
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const lower = {
+    call(value) {
+        const text = castAsText(value);
+        return text?.toLowerCase() ?? null;
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const hex = {
+    call(value) {
+        const binary = castAsBlob(value);
+        if (binary == null) {
+            return '';
+        }
+        return Buffer.from(binary).toString('hex').toUpperCase();
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const length = {
+    call(value) {
+        if (value == null) {
+            return null;
+        }
+        else if (value instanceof Uint8Array) {
+            return BigInt(value.byteLength);
+        }
+        else {
+            value = castAsText(value);
+            return BigInt(value.length);
+        }
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.INTEGER;
+    }
+};
+const base64 = {
+    call(value) {
+        const binary = castAsBlob(value);
+        if (binary == null) {
+            return '';
+        }
+        return Buffer.from(binary).toString('base64');
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const fn_typeof = {
+    call(value) {
+        return sqliteTypeOf(value);
+    },
+    parameters: [{ name: 'value', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const ifnull = {
+    call(x, y) {
+        if (x == null) {
+            return y;
+        }
+        else {
+            return x;
+        }
+    },
+    parameters: [
+        { name: 'x', type: ExpressionType.ANY, optional: false },
+        { name: 'y', type: ExpressionType.ANY, optional: false }
+    ],
+    getReturnType(args) {
+        if (args.length == 0) {
+            return ExpressionType.NONE;
+        }
+        else if (args.length == 1) {
+            return args[0];
+        }
+        else {
+            return args[0].or(args[1]);
+        }
+    }
+};
+const json_extract = {
+    call(json, path) {
+        return jsonExtract(json, path, 'json_extract');
+    },
+    parameters: [
+        { name: 'json', type: ExpressionType.ANY, optional: false },
+        { name: 'path', type: ExpressionType.ANY, optional: false }
+    ],
+    getReturnType(args) {
+        return ExpressionType.ANY_JSON;
+    }
+};
+const json_array_length = {
+    call(json, path) {
+        if (path != null) {
+            json = json_extract.call(json, path);
+        }
+        const jsonString = castAsText(json);
+        if (jsonString == null) {
+            return null;
+        }
+        const jsonParsed = JSONBig.parse(jsonString);
+        if (!Array.isArray(jsonParsed)) {
+            return 0n;
+        }
+        return BigInt(jsonParsed.length);
+    },
+    parameters: [
+        { name: 'json', type: ExpressionType.ANY, optional: false },
+        { name: 'path', type: ExpressionType.ANY, optional: true }
+    ],
+    getReturnType(args) {
+        return ExpressionType.INTEGER;
+    }
+};
+const json_valid = {
+    call(json) {
+        const jsonString = castAsText(json);
+        if (jsonString == null) {
+            return SQLITE_FALSE;
+        }
+        try {
+            JSONBig.parse(jsonString);
+            return SQLITE_TRUE;
+        }
+        catch (e) {
+            return SQLITE_FALSE;
+        }
+    },
+    parameters: [{ name: 'json', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.INTEGER;
+    }
+};
+const unixepoch = {
+    call(value, specifier, specifier2) {
+        if (value == null) {
+            return null;
+        }
+        let flags = {
+            unixepoch: false,
+            subsecond: false
+        };
+        if (specifier == null) {
+        }
+        else if (specifier == 'unixepoch') {
+            flags.unixepoch = true;
+            if (specifier2 == null) {
+            }
+            else if (specifier2 == 'subsec' || specifier2 == 'subsecond') {
+                flags.subsecond = true;
+            }
+            else {
+                return null;
+            }
+        }
+        else if (specifier == 'subsec' || specifier == 'subsecond') {
+            flags.subsecond = true;
+        }
+        else {
+            return null;
+        }
+        const epoch = convertToDate(value, flags)?.getTime();
+        if (epoch == null || !Number.isFinite(epoch)) {
+            return null;
+        }
+        if (flags.subsecond) {
+            return epoch / 1000.0;
+        }
+        else {
+            return BigInt(Math.floor(epoch / 1000.0));
+        }
+    },
+    parameters: [
+        { name: 'value', type: ExpressionType.ANY, optional: false },
+        { name: 'specifier', type: ExpressionType.ANY, optional: true },
+        { name: 'specifier2', type: ExpressionType.ANY, optional: true }
+    ],
+    getReturnType(args) {
+        return ExpressionType.INTEGER.or(ExpressionType.REAL);
+    }
+};
+const datetime = {
+    call(value, specifier, specifier2) {
+        if (value == null) {
+            return null;
+        }
+        let flags = {
+            unixepoch: false,
+            subsecond: false
+        };
+        if (specifier == null) {
+        }
+        else if (specifier == 'unixepoch') {
+            flags.unixepoch = true;
+            if (specifier2 == null) {
+            }
+            else if (specifier2 == 'subsec' || specifier2 == 'subsecond') {
+                flags.subsecond = true;
+            }
+            else {
+                return null;
+            }
+        }
+        else if (specifier == 'subsec' || specifier == 'subsecond') {
+            flags.subsecond = true;
+        }
+        else {
+            return null;
+        }
+        const epoch = convertToDate(value, flags);
+        if (epoch == null || !Number.isFinite(epoch.getTime())) {
+            return null;
+        }
+        const baseString = epoch.toISOString().replace(/T/, ' ').replace(/^\-0+/, '-');
+        if (flags.subsecond) {
+            return baseString.replace(/Z$/, '');
+        }
+        else {
+            return baseString.replace(/(\.\d+)?Z$/, '');
+        }
+    },
+    parameters: [
+        { name: 'value', type: ExpressionType.ANY, optional: false },
+        { name: 'specifier', type: ExpressionType.ANY, optional: true },
+        { name: 'specifier2', type: ExpressionType.ANY, optional: true }
+    ],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const st_asgeojson = {
+    call(geometry) {
+        const geo = parseGeometry(geometry);
+        if (geo == null) {
+            return null;
+        }
+        return JSONBig.stringify(geo.toGeoJSON());
+    },
+    parameters: [{ name: 'geometry', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const st_astext = {
+    call(geometry) {
+        const geo = parseGeometry(geometry);
+        if (geo == null) {
+            return null;
+        }
+        return geo.toWkt();
+    },
+    parameters: [{ name: 'geometry', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.TEXT;
+    }
+};
+const st_x = {
+    call(geometry) {
+        const geo = parseGeometry(geometry);
+        if (geo == null) {
+            return null;
+        }
+        if (geo instanceof wkx.Point) {
+            return geo.x;
+        }
+        return null;
+    },
+    parameters: [{ name: 'geometry', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.REAL;
+    }
+};
+const st_y = {
+    call(geometry) {
+        const geo = parseGeometry(geometry);
+        if (geo == null) {
+            return null;
+        }
+        if (geo instanceof wkx.Point) {
+            return geo.y;
+        }
+        return null;
+    },
+    parameters: [{ name: 'geometry', type: ExpressionType.ANY, optional: false }],
+    getReturnType(args) {
+        return ExpressionType.REAL;
+    }
+};
+export const SQL_FUNCTIONS_NAMED = {
+    upper,
+    lower,
+    hex,
+    length,
+    base64,
+    typeof: fn_typeof,
+    ifnull,
+    json_extract,
+    json_array_length,
+    json_valid,
+    unixepoch,
+    datetime,
+    st_asgeojson,
+    st_astext,
+    st_x,
+    st_y
+};
+export const SQL_FUNCTIONS_CALL = Object.fromEntries(Object.entries(SQL_FUNCTIONS_NAMED).map(([name, fn]) => [name, fn.call]));
+export const SQL_FUNCTIONS = SQL_FUNCTIONS_NAMED;
+export const CAST_TYPES = new Set(['text', 'numeric', 'integer', 'real', 'blob']);
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export function castAsText(value) {
+    if (value == null) {
+        return null;
+    }
+    else if (value instanceof Uint8Array) {
+        return textDecoder.decode(value);
+    }
+    else {
+        return value.toString();
+    }
+}
+export function castAsBlob(value) {
+    if (value == null) {
+        return null;
+    }
+    else if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (typeof value != 'string') {
+        value = value.toString();
+    }
+    return textEncoder.encode(value);
+}
+export function cast(value, to) {
+    if (value == null) {
+        return null;
+    }
+    if (to == 'text') {
+        return castAsText(value);
+    }
+    else if (to == 'numeric') {
+        if (value instanceof Uint8Array) {
+            value = textDecoder.decode(value);
+        }
+        if (typeof value == 'string') {
+            return parseNumeric(value);
+        }
+        else if (typeof value == 'number' || typeof value == 'bigint') {
+            return value;
+        }
+        else {
+            return 0n;
+        }
+    }
+    else if (to == 'real') {
+        if (value instanceof Uint8Array) {
+            value = textDecoder.decode(value);
+        }
+        if (typeof value == 'string') {
+            const nr = parseFloat(value);
+            if (isNaN(nr)) {
+                return 0.0;
+            }
+            else {
+                return nr;
+            }
+        }
+        else if (typeof value == 'number') {
+            return value;
+        }
+        else if (typeof value == 'bigint') {
+            return Number(value);
+        }
+        else {
+            return 0.0;
+        }
+    }
+    else if (to == 'integer') {
+        if (value instanceof Uint8Array) {
+            value = textDecoder.decode(value);
+        }
+        if (typeof value == 'string') {
+            return parseBigInt(value);
+        }
+        else if (typeof value == 'number') {
+            return Number.isInteger(value) ? BigInt(value) : BigInt(Math.floor(value));
+        }
+        else if (typeof value == 'bigint') {
+            return value;
+        }
+        else {
+            return 0n;
+        }
+    }
+    else if (to == 'blob') {
+        return castAsBlob(value);
+    }
+    else {
+        throw new Error(`Type not supported for cast: '${to}'`);
+    }
+}
+export function sqliteTypeOf(arg) {
+    if (arg == null) {
+        return 'null';
+    }
+    else if (typeof arg == 'string') {
+        return 'text';
+    }
+    else if (typeof arg == 'bigint') {
+        return 'integer';
+    }
+    else if (typeof arg == 'number') {
+        return 'real';
+    }
+    else if (arg instanceof Uint8Array) {
+        return 'blob';
+    }
+    else {
+        // Should not happen
+        throw new Error(`Unknown type: ${arg}`);
+    }
+}
+export function parseGeometry(value) {
+    let blob;
+    if (value == null) {
+        return null;
+    }
+    else if (value instanceof Uint8Array) {
+        blob = Buffer.from(value);
+    }
+    else if (typeof value == 'string') {
+        blob = Buffer.from(value, 'hex');
+    }
+    else {
+        return null;
+    }
+    const geo = wkx.Geometry.parse(blob);
+    return geo;
+}
+function parseNumeric(text) {
+    const match = /^\s*(\d+)(\.\d*)?(e[+\-]?\d+)?/i.exec(text);
+    if (!match) {
+        return 0n;
+    }
+    if (match[2] != null || match[3] != null) {
+        const v = parseFloat(match[0]);
+        return isNaN(v) ? 0n : v;
+    }
+    else {
+        return BigInt(match[1]);
+    }
+}
+function parseBigInt(text) {
+    const match = /^\s*(\d+)/.exec(text);
+    if (!match) {
+        return 0n;
+    }
+    return BigInt(match[1]);
+}
+function isNumeric(a) {
+    return typeof a == 'number' || typeof a == 'bigint';
+}
+export function evaluateOperator(op, a, b) {
+    switch (op) {
+        case '=':
+        case '!=':
+        case '>':
+        case '<':
+        case '>=':
+        case '<=': {
+            if (a == null || b == null) {
+                return null;
+            }
+            const diff = compare(a, b);
+            if (op == '=') {
+                return sqliteBool(diff === 0);
+            }
+            else if (op == '!=') {
+                return sqliteBool(diff !== 0);
+            }
+            else if (op == '>') {
+                return sqliteBool(diff > 0);
+            }
+            else if (op == '<') {
+                return sqliteBool(diff < 0);
+            }
+            else if (op == '>=') {
+                return sqliteBool(diff >= 0);
+            }
+            else if (op == '<=') {
+                return sqliteBool(diff <= 0);
+            }
+            else {
+                throw new Error('unreachable');
+            }
+        }
+        // Not currently supported by the parser, but used with IS NULL
+        case 'IS': {
+            const diff = compare(a, b);
+            return sqliteBool(diff === 0);
+        }
+        // Not currently supported by the parser, but used with IS NOT NULL
+        case 'IS NOT': {
+            const diff = compare(a, b);
+            return sqliteBool(diff !== 0);
+        }
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+            return doMath(op, a, b);
+        case '||':
+            return concat(a, b);
+        case 'AND':
+            return sqliteBool(sqliteBool(a) && sqliteBool(b));
+        case 'OR':
+            return sqliteBool(sqliteBool(a) || sqliteBool(b));
+        case 'IN':
+            if (a == null || b == null) {
+                return null;
+            }
+            if (typeof b != 'string') {
+                throw new Error('IN is only supported on JSON arrays');
+            }
+            const bParsed = JSON.parse(b);
+            if (!Array.isArray(bParsed)) {
+                throw new Error('IN is only supported on JSON arrays');
+            }
+            return sqliteBool(bParsed.includes(a));
+        default:
+            throw new Error(`Operator not supported: ${op}`);
+    }
+}
+export function getOperatorReturnType(op, left, right) {
+    switch (op) {
+        case '=':
+        case '!=':
+        case '>':
+        case '<':
+        case '>=':
+        case '<=': {
+            return ExpressionType.INTEGER;
+        }
+        // Not currently supported by the parser, but used with IS NULL
+        case 'IS': {
+            return ExpressionType.INTEGER;
+        }
+        // Not currently supported by the parser, but used with IS NOT NULL
+        case 'IS NOT': {
+            return ExpressionType.INTEGER;
+        }
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+            if (left.typeFlags == TYPE_INTEGER && right.typeFlags == TYPE_INTEGER) {
+                // INT, INT stays INT
+                return ExpressionType.INTEGER;
+            }
+            else if (left.isNumericOnly() && right.isNumericOnly()) {
+                // INT, REAL or REAL, INT or REAL, REAL => always REAL
+                return ExpressionType.REAL;
+            }
+            else {
+                // Unknown - could be REAL or INT
+                return ExpressionType.NUMERIC;
+            }
+        case '||':
+            return ExpressionType.TEXT;
+        case 'AND':
+            return ExpressionType.INTEGER;
+        case 'OR':
+            return ExpressionType.INTEGER;
+        case 'IN':
+            return ExpressionType.INTEGER;
+        default:
+            return ExpressionType.NONE;
+    }
+}
+function doMath(op, a, b) {
+    if (a == null || b == null) {
+        return null;
+    }
+    let na = cast(a, 'numeric');
+    let nb = cast(b, 'numeric');
+    if (typeof na == 'bigint' && typeof nb != 'bigint') {
+        // bigint, real
+        na = Number(na);
+    }
+    else if (typeof na != 'bigint' && typeof nb == 'bigint') {
+        // real, bigint
+        nb = Number(nb);
+    }
+    switch (op) {
+        case '+':
+            return na + nb;
+        case '-':
+            return na - nb;
+        case '*':
+            return na * nb;
+        case '/':
+            return na / nb;
+        default:
+            throw new Error(`Operator not supported: ${op}`);
+    }
+}
+function concat(a, b) {
+    const aText = castAsText(a);
+    const bText = castAsText(b);
+    if (aText == null || bText == null) {
+        return null;
+    }
+    return aText + bText;
+}
+export function jsonExtract(sourceValue, path, operator) {
+    const valueText = castAsText(sourceValue);
+    const pathText = castAsText(path);
+    if (valueText == null || pathText == null) {
+        return null;
+    }
+    const components = pathText.split('.');
+    if (components[0] == '$') {
+        components.shift();
+    }
+    else if (operator == 'json_extract') {
+        throw new Error(`JSON path must start with $.`);
+    }
+    let value = JSONBig.parse(valueText);
+    for (let c of components) {
+        if (value == null) {
+            break;
+        }
+        value = value[c];
+    }
+    if (operator == '->') {
+        // -> must always stringify
+        return JSONBig.stringify(value);
+    }
+    else if (typeof value == 'object' || Array.isArray(value)) {
+        // Objects and arrays must be stringified
+        return JSONBig.stringify(value);
+    }
+    else {
+        // Plain scalar value - simple conversion.
+        return jsonValueToSqlite(value);
+    }
+}
+export function convertToDate(dateTime, flags) {
+    if (typeof dateTime == 'string') {
+        return parseUTCDate(dateTime);
+    }
+    else if (typeof dateTime == 'bigint') {
+        if (flags.unixepoch) {
+            return new Date(Number(dateTime) * 1000.0);
+        }
+        else {
+            return julianToJSDate(Number(dateTime));
+        }
+    }
+    else if (typeof dateTime == 'number') {
+        if (flags.unixepoch) {
+            return new Date(dateTime * 1000.0);
+        }
+        else {
+            return julianToJSDate(dateTime);
+        }
+    }
+    else {
+        return null;
+    }
+}
+function parseUTCDate(isoDateString) {
+    const hasTimezone = /[Zz]|[+\-]\d{2}:\d{2}$/;
+    const isJulienDay = /^\d+(\.\d*)?$/;
+    if (hasTimezone.test(isoDateString)) {
+        // If the string already has a timezone, parse it directly
+        return new Date(isoDateString);
+    }
+    else if (isJulienDay.test(isoDateString)) {
+        return julianToJSDate(parseFloat(isoDateString));
+    }
+    else {
+        // If the string has no timezone, append "Z" to the end to interpret it as UTC
+        return new Date(isoDateString + 'Z');
+    }
+}
+function julianToJSDate(julianDay) {
+    // The Julian date for the Unix Epoch is 2440587.5
+    const julianAtEpoch = 2440587.5;
+    // Calculate the difference between the Julian date and the Unix Epoch in days
+    const daysSinceEpoch = julianDay - julianAtEpoch;
+    // Convert this to milliseconds
+    const msSinceEpoch = daysSinceEpoch * 24 * 60 * 60 * 1000;
+    // Create a new Date object with this number of milliseconds since the Unix Epoch
+    return new Date(msSinceEpoch);
+}
+const TYPE_ORDERING = {
+    null: 0,
+    integer: 1,
+    real: 1,
+    text: 2,
+    blob: 3
+};
+function compare(a, b) {
+    // https://www.sqlite.org/datatype3.html#comparisons
+    if (a == null && b == null) {
+        // Only for IS / IS NOT
+        return 0;
+    }
+    if ((isNumeric(a) && isNumeric(b)) || (typeof a == 'string' && typeof b == 'string')) {
+        if (a == b) {
+            return 0;
+        }
+        else if (a > b) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    else if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        throw new Error('Comparing blobs is not supported currently');
+    }
+    const typeA = sqliteTypeOf(a);
+    const typeB = sqliteTypeOf(b);
+    return TYPE_ORDERING[typeA] - TYPE_ORDERING[typeB];
+}
+//# sourceMappingURL=sql_functions.js.map