@laserdata/laser-sdk 0.5.3 → 0.6.0

package/dist/wire/filter.js

@@ -96,6 +96,16 @@ export class FieldPath {
         }
         return new FieldPath(segments);
     }
+    static tryParse(text) {
+        try {
+            return FieldPath.parse(text);
+        }
+        catch (error) {
+            if (error instanceof InvalidError)
+                return undefined;
+            throw error;
+        }
+    }
     toString() {
         return this.segments
             .map((segment, position) => {
@@ -183,6 +193,9 @@ class PathParser {
         return new InvalidError(`field path \`${this.text}\` is invalid at byte ${String(byte)}: ${reason}`);
     }
 }
+export function recordPolicyIsReject(policy) {
+    return policy === "reject";
+}
 /** Builders for the `FilterExpr` type. */
 export const FilterExpr = {
     all(children) {
@@ -209,6 +222,16 @@ export const FilterExpr = {
     absent(path) {
         return { kind: "absent", path: FieldPath.parse(path) };
     },
+    /** Presence of a payload path, `undefined` for an invalid path. */
+    tryPresent(path) {
+        const parsed = FieldPath.tryParse(path);
+        return parsed === undefined ? undefined : { kind: "present", path: parsed };
+    },
+    /** Absence of a payload path, `undefined` for an invalid path. */
+    tryAbsent(path) {
+        const parsed = FieldPath.tryParse(path);
+        return parsed === undefined ? undefined : { kind: "absent", path: parsed };
+    },
     header(key, op, value) {
         return { kind: "header", predicate: { key, op, value: typedLiteral(value) } };
     },
@@ -260,6 +283,13 @@ export const ConsumerFilter = {
     /** The same filter under another policy for a field of an unexpected type. */
     withMismatchPolicy(filter, mismatchPolicy) {
         return { ...filter, mismatchPolicy };
+    },
+    /**
+     * SHA-256 over a domain tag and the canonical JSON encoding of the filter.
+     * Two filters get the same digest exactly when their encodings are equal.
+     */
+    digest(filter) {
+        return consumerFilterDigest(filter);
     }
 };
 function newFilter(expr, codec, faultPolicy) {
@@ -291,6 +321,12 @@ function typedLiteral(value) {
     }
     return value;
 }
+/** Makes a text match case-insensitive. Any other node is returned as is. */
+export function filterExprCaseInsensitive(expr) {
+    if (expr.kind !== "text" && expr.kind !== "header_text")
+        return expr;
+    return { kind: expr.kind, predicate: { ...expr.predicate, caseInsensitive: true } };
+}
 export function filterExprReadsPayload(expr) {
     switch (expr.kind) {
         case "all":
@@ -433,11 +469,11 @@ function validateNode(expr, depth, nodes) {
             return;
         case "text":
             FieldPath.parse(expr.predicate.field);
-            validateTextPredicate(expr.predicate);
+            textPredicateValidate(expr.predicate);
             return;
         case "header_text":
             validateHeaderKey(expr.predicate.field);
-            validateTextPredicate(expr.predicate);
+            textPredicateValidate(expr.predicate);
     }
 }
 function validateHeaderKey(key) {
@@ -449,7 +485,7 @@ function validateHeaderKey(key) {
 // The server compiles regexes with the Rust engine and is the authority on
 // their syntax. These checks refuse what no SDK accepts, so a filter fails here
 // before it travels.
-function validateTextPredicate(predicate) {
+export function textPredicateValidate(predicate) {
     if (UTF8.encode(predicate.pattern).byteLength > MAX_FILTER_STRING_BYTES) {
         throw new InvalidError(`a text pattern exceeds ${String(MAX_FILTER_STRING_BYTES)}B`);
     }
@@ -617,10 +653,10 @@ function coercedLiteralParses(coerce, value) {
         return value.kind === "string" && ExactDecimal.parse(value.value) !== undefined;
     }
     if (value.kind === "string") {
-        return timestampFromText(coerce.format, value.value) !== undefined;
+        return timestampFormatMicrosFromText(coerce.format, value.value) !== undefined;
     }
     if (value.kind === "int" || value.kind === "long") {
-        return timestampFromInteger(coerce.format, BigInt(value.value)) !== undefined;
+        return timestampFormatMicrosFromInteger(coerce.format, BigInt(value.value)) !== undefined;
     }
     return false;
 }
@@ -682,7 +718,7 @@ export class ExactDecimal {
         return ExactDecimal.normalized(negative, (negative ? -value : value).toString(), "");
     }
     /** The exact value of a finite double, `undefined` for infinities and NaN. */
-    static fromDouble(value) {
+    static fromF64(value) {
         if (!Number.isFinite(value))
             return undefined;
         if (value === 0)
@@ -745,15 +781,15 @@ function inI64(value) {
     return value >= I64_MIN && value <= I64_MAX ? value : undefined;
 }
 /** Microseconds since the epoch for a text value, `undefined` when it does not parse exactly. */
-export function timestampFromText(format, text) {
+export function timestampFormatMicrosFromText(format, text) {
     if (format === "rfc3339")
         return rfc3339Micros(text);
     if (!/^[+-]?\d+$/.test(text))
         return undefined;
-    return timestampFromInteger(format, BigInt(text));
+    return timestampFormatMicrosFromInteger(format, BigInt(text));
 }
 /** Microseconds since the epoch for an integer value, `undefined` on overflow or for RFC 3339. */
-export function timestampFromInteger(format, value) {
+export function timestampFormatMicrosFromInteger(format, value) {
     if (inI64(value) === undefined)
         return undefined;
     switch (format) {
@@ -864,8 +900,40 @@ function daysFromCivil(yearInput, month, day) {
     const dayOfEra = yearOfEra * 365n + yearOfEra / 4n - yearOfEra / 100n + dayOfYear;
     return era * 146097n + dayOfEra - 719468n;
 }
+export function filterConsumerIsGroup(consumer) {
+    return consumer.kind !== "consumer";
+}
+export function executionModeIsFiltered(mode) {
+    return mode === "filtered";
+}
+export function readModeIsPrimary(mode) {
+    return mode === "primary";
+}
+/**
+ * Whether the record is in another format than the filter reads, which follows
+ * the filter's foreign policy instead of its fault policy.
+ */
+export function faultReasonIsForeign(reason) {
+    return (reason === "foreign_codec" ||
+        reason === "missing_schema" ||
+        reason === "schema_not_allowed" ||
+        reason === "schema_mismatch");
+}
+/** The policy an independent consumer or a bound group ran: one filter. */
+export function appliedPolicyFiltered(groupId, digest) {
+    return {
+        ...(groupId === undefined ? {} : { groupId }),
+        digest,
+        mode: "filtered",
+        policyGeneration: 0n
+    };
+}
+/** The policy of a group without a binding: every record. */
+export function appliedPolicyUnfiltered(groupId, policyGeneration) {
+    return { groupId, mode: "unfiltered", policyGeneration };
+}
 /** The start of the next request: continue after `page`, or repeat `original`. */
-export function nextFilteredStart(page, original) {
+export function filteredPageNextStart(page, original) {
     if (page.nextScanOffset === undefined)
         return original;
     return {
@@ -881,6 +949,27 @@ export function nextFilteredStart(page, original) {
         }
     };
 }
+export function filterErrorInvalid(error) {
+    return {
+        code: { kind: "known", name: "InvalidArgument" },
+        reason: "invalid_request",
+        message: error.message
+    };
+}
+/**
+ * Refuses a request of another filter op version as `version_skew` before its
+ * shape is validated, so a client of another build can tell a version gap from
+ * a malformed request. `undefined` for the supported version.
+ */
+export function filterErrorCheckVersion(v) {
+    if (v === FILTER_OP_VERSION)
+        return undefined;
+    return {
+        code: { kind: "known", name: "VersionSkew" },
+        reason: "version_skew",
+        message: `filter request version ${String(v)} is not supported, expected ${String(FILTER_OP_VERSION)}`
+    };
+}
 function validateVersion(v) {
     if (v !== FILTER_OP_VERSION) {
         throw new InvalidError(`filter request version ${String(v)} is not supported, expected ${String(FILTER_OP_VERSION)}`);