@speedkit/cli 4.25.2 → 4.27.0

package/dist/services/query-builder/sql/spec/predicate.spec.js

@@ -0,0 +1,78 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { and, FALSE, isFalse, isTrue, leaf, not, or, predicateKey, TRUE, } from "../predicate.js";
+const a = leaf("a");
+const b = leaf("b");
+const c = leaf("c");
+describe("predicate and", () => {
+    it("should be true without operands", () => {
+        expect(isTrue(and())).to.equal(true);
+    });
+    it("should return the only operand unwrapped", () => {
+        expect(and(a)).to.deep.equal(a);
+    });
+    it("should drop true operands", () => {
+        expect(and(a, TRUE, b)).to.deep.equal({
+            children: [a, b],
+            kind: "and",
+        });
+    });
+    it("should collapse to false on a false operand", () => {
+        expect(isFalse(and(a, FALSE))).to.equal(true);
+    });
+    it("should flatten nested conjunctions", () => {
+        expect(and(a, and(b, c))).to.deep.equal({
+            children: [a, b, c],
+            kind: "and",
+        });
+    });
+    it("should remove duplicate operands", () => {
+        expect(and(a, b, leaf("a"))).to.deep.equal({
+            children: [a, b],
+            kind: "and",
+        });
+    });
+    it("should collapse to false on contradicting operands", () => {
+        expect(isFalse(and(a, b, not(leaf("a"))))).to.equal(true);
+    });
+    it("should keep a disjunction as an operand", () => {
+        expect(and(a, or(b, c))).to.deep.equal({
+            children: [a, { children: [b, c], kind: "or" }],
+            kind: "and",
+        });
+    });
+});
+describe("predicate or", () => {
+    it("should be false without operands", () => {
+        expect(isFalse(or())).to.equal(true);
+    });
+    it("should drop false operands", () => {
+        expect(or(a, FALSE, b)).to.deep.equal({
+            children: [a, b],
+            kind: "or",
+        });
+    });
+    it("should collapse to true on a true operand", () => {
+        expect(isTrue(or(a, TRUE))).to.equal(true);
+    });
+    it("should collapse to true on complementary operands", () => {
+        expect(isTrue(or(a, not(leaf("a"))))).to.equal(true);
+    });
+});
+describe("predicate not", () => {
+    it("should collapse a double negation", () => {
+        expect(not(not(a))).to.deep.equal(a);
+    });
+    it("should negate the constants", () => {
+        expect(isFalse(not(TRUE))).to.equal(true);
+        expect(isTrue(not(FALSE))).to.equal(true);
+    });
+});
+describe("predicateKey", () => {
+    it("should not depend on the operand order", () => {
+        expect(predicateKey(and(a, b))).to.equal(predicateKey(and(b, a)));
+    });
+    it("should differ between and and or", () => {
+        expect(predicateKey(and(a, b))).to.not.equal(predicateKey(or(a, b)));
+    });
+});

package/dist/services/query-builder/sql/spec/regex.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/query-builder/sql/spec/regex.spec.js

@@ -0,0 +1,62 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { escapeRegexLiteral, toAthenaRegex } from "../regex.js";
+describe("toAthenaRegex", () => {
+    it("should keep a plain pattern", () => {
+        expect(toAthenaRegex(/^\/products\/\d+$/).pattern).to.equal(String.raw `^/products/\d+$`);
+    });
+    it("should move the i flag into the pattern", () => {
+        expect(toAthenaRegex(/^\/p\//i).pattern).to.equal(String.raw `(?i)^/p/`);
+    });
+    it("should combine the flags in a single group", () => {
+        expect(toAthenaRegex(/a.b/ims).pattern).to.equal("(?ims)a.b");
+    });
+    it("should ignore flags without a pattern equivalent", () => {
+        expect(toAthenaRegex(/abc/g).pattern).to.equal("abc");
+    });
+    it("should unescape a slash", () => {
+        expect(toAthenaRegex(/\/de\/shop/i).pattern).to.equal("(?i)/de/shop");
+    });
+    it("should keep an escaped backslash", () => {
+        expect(toAthenaRegex(/a\\b/).pattern).to.equal(String.raw `a\\b`);
+    });
+    it("should not warn about a pattern it fully supports", () => {
+        expect(toAthenaRegex(/^\/(shop|store)\/[a-z-]+$/i).warnings).to.deep.equal([]);
+    });
+    it("should keep lookahead without a warning", () => {
+        const { pattern, warnings } = toAthenaRegex(/^[^?]*\/(\?|$)/i);
+        expect(pattern).to.equal(String.raw `(?i)^[^?]*/(\?|$)`);
+        expect(warnings).to.deep.equal([]);
+    });
+    it("should warn about lookbehind", () => {
+        const { warnings } = toAthenaRegex(/(?<=\/de)\/shop/i);
+        expect(warnings).to.have.lengthOf(1);
+        expect(warnings[0]).to.contain("lookbehind");
+    });
+    it("should warn about a back reference", () => {
+        const { warnings } = toAthenaRegex(/(a)\1/);
+        expect(warnings).to.have.lengthOf(1);
+        expect(warnings[0]).to.contain("back reference");
+    });
+    it("should not read a back reference inside a character class", () => {
+        // Written through the constructor because TypeScript rejects the literal.
+        const inClass = new RegExp(String.raw `[\1]`);
+        expect(toAthenaRegex(inClass).warnings).to.deep.equal([]);
+    });
+    it("should warn about a unicode property escape", () => {
+        const { warnings } = toAthenaRegex(/\p{Letter}/u);
+        expect(warnings).to.have.lengthOf(1);
+        expect(warnings[0]).to.contain("unicode property");
+    });
+    it("should report each construct once", () => {
+        expect(toAthenaRegex(/(a)\1(b)\2/).warnings).to.have.lengthOf(1);
+    });
+});
+describe("escapeRegexLiteral", () => {
+    it("should escape the regex metacharacters", () => {
+        expect(escapeRegexLiteral("utm_source?")).to.equal(String.raw `utm_source\?`);
+    });
+    it("should leave a plain parameter name alone", () => {
+        expect(escapeRegexLiteral("gclid")).to.equal("gclid");
+    });
+});

package/dist/services/revalidate/revalidate-model.d.ts

@@ -6,11 +6,17 @@ export type RevalidateType = (typeof REVALIDATE_TYPES)[number];
  */
 export declare const ASSET_TABLE = "speedKit.Asset";
 /**
- * Above this many assets the command asks before it purges. A filter that takes
- * more than a page of assets is usually a filter mistake, and a purge cannot be
- * undone — the entries are gone until traffic caches them again.
+ * Above this many assets the command asks before it runs a job that drops
+ * entries. Such a job cannot be undone: the entries are gone until traffic
+ * caches them again.
  */
 export declare const CONFIRMATION_THRESHOLD = 100;
+/**
+ * The job types that stop serving the cached entry straight away, so a large one
+ * needs the confirmation. `REFRESH` and `INSTANT` keep serving while they
+ * revalidate, so they need none.
+ */
+export declare const DROPPING_TYPES: ReadonlySet<RevalidateType>;
 /**
  * Scope of a revalidation job.
  *

package/dist/services/revalidate/revalidate-model.js

@@ -10,11 +10,20 @@ export const REVALIDATE_TYPES = [
  */
 export const ASSET_TABLE = "speedKit.Asset";
 /**
- * Above this many assets the command asks before it purges. A filter that takes
- * more than a page of assets is usually a filter mistake, and a purge cannot be
- * undone — the entries are gone until traffic caches them again.
+ * Above this many assets the command asks before it runs a job that drops
+ * entries. Such a job cannot be undone: the entries are gone until traffic
+ * caches them again.
  */
 export const CONFIRMATION_THRESHOLD = 100;
+/**
+ * The job types that stop serving the cached entry straight away, so a large one
+ * needs the confirmation. `REFRESH` and `INSTANT` keep serving while they
+ * revalidate, so they need none.
+ */
+export const DROPPING_TYPES = new Set([
+    "PURGE",
+    "DEPLOYMENT",
+]);
 export class RevalidateContext {
     app;
     quiet;