@thomasfosterau/pulpit 0.0.0-stage → 0.1.0

package/dist/filter.d.ts

@@ -0,0 +1,461 @@
+/**
+ * **The list-filter vocabulary** — the kernel's read predicates as data.
+ *
+ * Every visibility, soft-delete and publication rule the kernel owns has two
+ * readings: a per-row answer (may this viewer see this row?) and a set-shaped
+ * answer a LIST turns into its `WHERE`. In the apps the second is Drizzle SQL
+ * built inline (`ownedListFilterE`, `loadListVisibilityFilters`,
+ * `publishedFilter`), which ties the rule to one database layer and makes the
+ * two readings impossible to compare. Here the set-shaped answer is a small
+ * predicate tree, {@link ListFilter}: a Drizzle renderer (the seam
+ * effect-drizzle-ext / effect-auth-drizzle fill, see the package README →
+ * Seams) turns it into SQL, and
+ * {@link evaluate} runs it against an in-memory row — which is what lets the
+ * unit suite prove the list filter and the row predicate never disagree.
+ *
+ * `Following` is whatever a seam hands the `in` node: the follower seam's
+ * set of followed accounts, or an edge family's members
+ * (`EdgeStore.members`, pulpit#113); a subquery (`SQLWrapper`) for SQL, a
+ * set for the in-memory evaluator. The `notIn` node takes the same
+ * `Following`, for an exclusion (`EdgeOps.nonMemberFilter`, pulpit#191).
+ *
+ * Rendering contract a SQL renderer must honour:
+ *
+ * | node | SQL |
+ * | --- | --- |
+ * | `always` | no predicate (`undefined` to Drizzle's `.where`) |
+ * | `never` | a predicate no row satisfies (the apps: `id = '00000000-…'`) |
+ * | `eq` / `ne` | `col = $v` / `col <> $v` — a `NULL` column satisfies neither |
+ * | `in` | `col IN (<seam subquery>)` — a subquery, never a materialised array (#1107); a `NULL` column satisfies none |
+ * | `notIn` | `(col IS NULL OR col NOT IN (<seam subquery>))` — the complement of `in` over the same subquery (pulpit#191); a `NULL` column satisfies it, and the subquery must never yield a `NULL` (`NOT IN` over a set holding one is `NULL` for every row) |
+ * | `gt` / `gte` / `lt` / `lte` | `col > $v` / `col >= $v` / `col < $v` / `col <= $v` — a string compared with `COLLATE "C"` (code-point order), a `Date` as a timestamp, a number numerically (`±Infinity` included); a `NULL` column satisfies none |
+ * | `anyOf` | `col = ANY($values)` — a `NULL` column satisfies none; empty is `never`; never a `NULL` element |
+ * | `noneOf` | `col <> ALL($values)` — a `NULL` column satisfies none; empty is `always` (`<> ALL` over no values is true); never a `NULL` element (`<> ALL('{1,NULL}')` is `NULL` for every row outside the set) |
+ * | `isNull` | `col IS NULL` — the one node a `NULL` column satisfies by itself |
+ * | `published` | `(col IS NOT NULL AND col <= now())` — the database's clock, one per query |
+ * | `notPublished` | `(col IS NULL OR col > now())` — parenthesised, so it cannot bind to a surrounding `AND` |
+ * | `locale` | `col = ANY($locales)` over the view's locale column (pulpit#56) — as `anyOf`; on a view with no locale level, `never` |
+ * | `and` / `or` | `AND` / `OR` over the parts |
+ *
+ * An `anyOf` / `noneOf` node carrying more than {@link MAX_SET_VALUES} values,
+ * duplicates counted, is `never`, in the renderer as in {@link evaluate}
+ * (`SEC-INPUT-003`); the constructors already fold it so.
+ *
+ * Outside the contract, where SQL and {@link evaluate} cannot be made to
+ * agree, `evaluate` fails closed:
+ *
+ * - **A column of another type than the comparand** (or than any of a
+ *   literal set's values) is a caller or schema error. SQL may coerce the
+ *   parameter (an `integer` column against `'1'`) or raise (against
+ *   `'abc'`); `evaluate` reads every such row as satisfying no `eq`, `ne`,
+ *   comparison, `anyOf` or `noneOf`.
+ * - **`NaN`** (and an invalid `Date`). PostgreSQL's `float8` / `numeric` hold
+ *   `NaN` equal to itself and above every number, an order JavaScript's
+ *   `NaN` does not have. The constructors fold a `NaN` comparand, or a set
+ *   holding one, to `never`; `evaluate` reads a `NaN` comparand or column as
+ *   satisfying no `eq`, `ne`, comparison, `anyOf` or `noneOf`; and a renderer
+ *   must never bind `NaN`, rendering a hand-built node carrying one as `never`.
+ * - **Sub-millisecond instants.** A PostgreSQL timestamp keeps microseconds,
+ *   a JavaScript `Date` milliseconds, so two instants within one millisecond
+ *   can compare unequal in SQL and equal in `evaluate`.
+ *
+ * @copyright Thomas Foster
+ * @module pulpit/filter
+ * @since 0.1.0
+ */
+import type { ColumnValue } from "./version-chain.ts";
+/**
+ * A value an `eq` / `ne` node compares against. No `null`: `col = NULL` is
+ * never true in SQL, so a null comparison would read differently in the
+ * renderer and the evaluator.
+ *
+ * @since 0.1.0
+ */
+export type Scalar = string | number | boolean;
+/**
+ * A value a `gt` / `gte` / `lt` / `lte` node compares against. A `string`
+ * orders by code point (SQL's `"C"` collation), a `number` numerically and a
+ * `Date` by its instant. Kept apart from {@link Scalar}, which `eq` / `ne`
+ * test by identity and so cannot hold a `Date`; a `boolean` has no order a
+ * filter needs.
+ *
+ * @since 0.1.0
+ */
+export type Comparable = string | number | Date;
+/**
+ * The most values an `anyOf` / `noneOf` node carries (`SEC-INPUT-003`): a
+ * literal set past it is `never`, so no request drives an unbounded
+ * `= ANY($values)` parameter. An application's own bound sits below it:
+ * `@thomasfosterau/pulpit-wordpress` caps each list parameter at 100, a cap
+ * WordPress core itself doesn't set (pulpit#86).
+ *
+ * @since 0.1.0
+ */
+export declare const MAX_SET_VALUES = 1000;
+/**
+ * A row as {@link evaluate} reads it: the view's columns by name.
+ *
+ * @since 0.1.0
+ */
+export type FilterRow = {
+    readonly [column: string]: ColumnValue;
+};
+/**
+ * A read predicate over a current-version view's columns.
+ *
+ * @since 0.1.0
+ */
+export type ListFilter<Following> = {
+    readonly kind: "always";
+} | {
+    readonly kind: "never";
+} | {
+    readonly kind: "eq";
+    readonly column: string;
+    readonly value: Scalar;
+} | {
+    readonly kind: "ne";
+    readonly column: string;
+    readonly value: Scalar;
+} | {
+    readonly kind: "in";
+    readonly column: string;
+    readonly set: Following;
+} | {
+    readonly kind: "notIn";
+    readonly column: string;
+    readonly set: Following;
+} | {
+    readonly kind: "gt";
+    readonly column: string;
+    readonly value: Comparable;
+} | {
+    readonly kind: "gte";
+    readonly column: string;
+    readonly value: Comparable;
+} | {
+    readonly kind: "lt";
+    readonly column: string;
+    readonly value: Comparable;
+} | {
+    readonly kind: "lte";
+    readonly column: string;
+    readonly value: Comparable;
+} | {
+    readonly kind: "anyOf";
+    readonly column: string;
+    readonly values: ReadonlyArray<Scalar>;
+} | {
+    readonly kind: "noneOf";
+    readonly column: string;
+    readonly values: ReadonlyArray<Scalar>;
+} | {
+    readonly kind: "isNull";
+    readonly column: string;
+} | {
+    readonly kind: "published";
+    readonly column: string;
+} | {
+    readonly kind: "notPublished";
+    readonly column: string;
+} | {
+    readonly kind: "locale";
+    readonly column: string;
+    readonly locales: ReadonlyArray<string>;
+} | {
+    readonly kind: "and";
+    readonly filters: ReadonlyArray<ListFilter<Following>>;
+} | {
+    readonly kind: "or";
+    readonly filters: ReadonlyArray<ListFilter<Following>>;
+};
+/**
+ * No predicate: every row.
+ *
+ * @since 0.1.0
+ */
+export declare const always: {
+    readonly kind: "always";
+};
+/**
+ * Fail closed: no row.
+ *
+ * @since 0.1.0
+ */
+export declare const never: {
+    readonly kind: "never";
+};
+/**
+ * `column = value`. A `NaN` value is {@link never}: PostgreSQL's `NaN = NaN`
+ * is true where JavaScript's is not, so it fails closed.
+ *
+ * @since 0.1.0
+ */
+export declare const eq: (column: string, value: Scalar) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "eq";
+    readonly column: string;
+    readonly value: Scalar;
+};
+/**
+ * `column <> value`. A `NULL` or absent column satisfies it no more than it
+ * satisfies {@link eq}: SQL's `NULL <> $v` is `NULL`, not true. A `NaN`
+ * value is {@link never}, failing closed.
+ *
+ * @since 0.1.0
+ */
+export declare const ne: (column: string, value: Scalar) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "ne";
+    readonly column: string;
+    readonly value: Scalar;
+};
+/**
+ * `column IN (following)`. A `NULL` or absent column satisfies none, whatever
+ * `following` holds: SQL's `NULL IN (…)` is `NULL`, not true.
+ *
+ * @since 0.1.0
+ */
+export declare const isIn: <Following>(column: string, set: Following) => {
+    readonly kind: "in";
+    readonly column: string;
+    readonly set: Following;
+};
+/**
+ * `(column IS NULL OR column NOT IN (following))` (pulpit#191): the exact
+ * complement of {@link isIn} over the same seam set, so `isIn(c, s)` and
+ * `isNotIn(c, s)` partition every row. A `NULL` or absent column satisfies
+ * it, whatever `following` holds, and is never asked about; the seam's set
+ * must never hold a `NULL` (SQL's `NOT IN` over one is `NULL` for every row).
+ *
+ * @example
+ * ```ts
+ * import { strictEqual } from "node:assert";
+ * import { evaluate, isNotIn } from "@thomasfosterau/pulpit/filter";
+ *
+ * const excluded = new Set(["a"]);
+ * const context = { now: new Date(0), contains: (set: Set<string>, value: unknown) => set.has(String(value)) };
+ * strictEqual(evaluate(isNotIn("id", excluded), { id: "a" }, context), false);
+ * strictEqual(evaluate(isNotIn("id", excluded), { id: "b" }, context), true);
+ * strictEqual(evaluate(isNotIn("id", excluded), { id: null }, context), true);
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare const isNotIn: <Following>(column: string, set: Following) => {
+    readonly kind: "notIn";
+    readonly column: string;
+    readonly set: Following;
+};
+/**
+ * `column > value`. A `NULL` or absent column satisfies it no more than SQL's
+ * `NULL > $v` (which is `NULL`); `evaluate` reads a column holding another
+ * type than `value` as satisfying none, too. A `NaN` or invalid-`Date` value
+ * is {@link never}. See {@link Comparable} for the orders.
+ *
+ * @since 0.1.0
+ */
+export declare const gt: (column: string, value: Comparable) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "gt";
+    readonly column: string;
+    readonly value: Comparable;
+};
+/**
+ * `column >= value`; equality satisfies it, `Infinity` against `Infinity`
+ * included. A `NULL` or absent column satisfies none (SQL's `NULL >= $v` is
+ * `NULL`); `evaluate` reads a column holding another type than `value` as
+ * satisfying none, too. A `NaN` or invalid-`Date` value is {@link never}.
+ *
+ * @since 0.1.0
+ */
+export declare const gte: (column: string, value: Comparable) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "gte";
+    readonly column: string;
+    readonly value: Comparable;
+};
+/**
+ * `column < value`. A `NULL` or absent column satisfies none (SQL's
+ * `NULL < $v` is `NULL`); `evaluate` reads a column holding another type than
+ * `value` as satisfying none, too. A `NaN` or invalid-`Date` value is
+ * {@link never}.
+ *
+ * @since 0.1.0
+ */
+export declare const lt: (column: string, value: Comparable) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "lt";
+    readonly column: string;
+    readonly value: Comparable;
+};
+/**
+ * `column <= value`; equality satisfies it, `-Infinity` against `-Infinity`
+ * included. A `NULL` or absent column satisfies none (SQL's `NULL <= $v` is
+ * `NULL`); `evaluate` reads a column holding another type than `value` as
+ * satisfying none, too. A `NaN` or invalid-`Date` value is {@link never}.
+ *
+ * @since 0.1.0
+ */
+export declare const lte: (column: string, value: Comparable) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "lte";
+    readonly column: string;
+    readonly value: Comparable;
+};
+/**
+ * `column = ANY(values)`: the column equals one of a literal set, each tested
+ * as {@link eq} tests its value. A `NULL` or absent column is in no set. No
+ * values is {@link never}, and so are more than {@link MAX_SET_VALUES}
+ * (duplicates counted, `SEC-INPUT-003`) and a set holding a `NaN`, so
+ * {@link and} / {@link or} fold each. This is a literal set; a follower
+ * subquery is {@link isIn}'s.
+ *
+ * @since 0.1.0
+ */
+export declare const anyOf: (column: string, values: ReadonlyArray<Scalar>) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "anyOf";
+    readonly column: string;
+    readonly values: readonly Scalar[];
+};
+/**
+ * `column <> ALL(values)`: the column equals none of a literal set, each
+ * tested as {@link ne} tests its value. A `NULL` or absent column satisfies it
+ * no more than it satisfies `ne` (SQL's `NULL <> ALL(…)` is `NULL`). No values
+ * is {@link always}; more than {@link MAX_SET_VALUES} (duplicates counted) is
+ * {@link never}, failing closed rather than excluding only some
+ * (`SEC-INPUT-003`), and so is a set holding a `NaN`.
+ *
+ * @since 0.1.0
+ */
+export declare const noneOf: (column: string, values: ReadonlyArray<Scalar>) => {
+    readonly kind: "always";
+} | {
+    readonly kind: "never";
+} | {
+    readonly kind: "noneOf";
+    readonly column: string;
+    readonly values: readonly Scalar[];
+};
+/**
+ * `column IS NULL`: the column holds no value (`evaluate` reads an absent
+ * column so, too). The one node a `NULL` column satisfies on its own, so
+ * `or(isNull(column), noneOf(column, values))` is the exclusion that keeps an
+ * unset column, which a bare {@link noneOf} drops (pulpit#170).
+ *
+ * @since 0.1.0
+ */
+export declare const isNull: (column: string) => {
+    readonly kind: "isNull";
+    readonly column: string;
+};
+/**
+ * Stamped, and the stamp has arrived.
+ *
+ * @since 0.1.0
+ */
+export declare const published: (column: string) => {
+    readonly kind: "published";
+    readonly column: string;
+};
+/**
+ * Not out: unstamped, or stamped in the future — the exact complement of {@link published}.
+ *
+ * @since 0.1.0
+ */
+export declare const notPublished: (column: string) => {
+    readonly kind: "notPublished";
+    readonly column: string;
+};
+/**
+ * The column a localised leaf's current-version view keys its locale level
+ * by (pulpit#56): one view row per `(id, locale)` the head carries, the
+ * shared columns joined in, and a node carrying no locale as one row whose
+ * `locale` is `NULL`. No leaf column may take the name.
+ *
+ * @since 0.1.0
+ */
+export declare const LOCALE_COLUMN = "locale";
+/**
+ * The locale arm (pulpit#56): the view rows in one of `locales`, read from
+ * the view's {@link LOCALE_COLUMN} as {@link anyOf} reads its column. A row
+ * carrying no locale (a `NULL` locale), and every row of a view with no
+ * locale level, is in none. No locales is {@link never}, and so are more than
+ * {@link MAX_SET_VALUES} (`SEC-INPUT-003`).
+ *
+ * @example
+ * ```ts
+ * import { strictEqual } from "node:assert";
+ * import { evaluate, locale } from "@thomasfosterau/pulpit/filter";
+ *
+ * const context = { now: new Date(0), contains: () => false };
+ * strictEqual(evaluate(locale(["fr", "en"]), { id: "a", locale: "fr" }, context), true);
+ * strictEqual(evaluate(locale(["fr", "en"]), { id: "a", locale: "de" }, context), false);
+ * strictEqual(evaluate(locale(["fr"]), { id: "a" }, context), false);
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare const locale: (locales: ReadonlyArray<string>) => {
+    readonly kind: "never";
+} | {
+    readonly kind: "locale";
+    readonly column: "locale";
+    readonly locales: readonly string[];
+};
+/**
+ * Conjunction. `always` parts drop out, a `never` part makes the whole
+ * `never`, and a single remaining part is returned bare — so composing
+ * optional filters reads as one call, the shape the apps' `combine` had.
+ *
+ * @since 0.1.0
+ */
+export declare const and: <Following>(...filters: ReadonlyArray<ListFilter<Following>>) => ListFilter<Following>;
+/**
+ * Disjunction. `never` parts drop out, an `always` part makes the whole
+ * `always`, and a single remaining part is returned bare.
+ *
+ * @since 0.1.0
+ */
+export declare const or: <Following>(...filters: ReadonlyArray<ListFilter<Following>>) => ListFilter<Following>;
+/**
+ * What {@link evaluate} needs besides the row: the query's clock and the `in` test.
+ *
+ * @since 0.1.0
+ */
+export interface EvaluationContext<Following> {
+    /** The instant `published` / `notPublished` compare against — the query's `now()`. */
+    readonly now: Date;
+    /**
+     * Whether `value` is a member of the follower seam's `set`. {@link evaluate}
+     * never asks it about a `null` or absent column: such a row satisfies no
+     * `in`, and every `notIn`, whatever this would answer.
+     */
+    readonly contains: (set: Following, value: ColumnValue) => boolean;
+}
+/**
+ * Run a filter against one row — the in-memory reading of the rendering
+ * contract above. A column that is `null` or that the row lacks matches no
+ * `eq`, satisfies no `ne`, `in`, comparison, `anyOf` or non-empty `noneOf`,
+ * satisfies every `notIn`, and is unpublished: SQL reads `NULL = $v`, `NULL <> $v`, `NULL IN (…)`,
+ * `NULL > $v` and `NULL <> ALL(…)` as `NULL`, which a `WHERE` drops, so `ne`
+ * is not the complement of `eq`, nor `noneOf` of `anyOf`, over a nullable
+ * column; {@link isNull} is the one node such a row satisfies. Such a row fails an `in` without `context.contains` being asked, so
+ * the answer never depends on the seam (pulpit#94). A set past
+ * {@link MAX_SET_VALUES} is `never`. Outside the contract it fails closed: a
+ * column of another type than the comparand (or than any of a set's values),
+ * and a `NaN` (or invalid `Date`) comparand, set element or column, satisfy
+ * no `eq`, `ne`, comparison, `anyOf` or non-empty `noneOf`.
+ *
+ * @since 0.1.0
+ */
+export declare const evaluate: <Following>(filter: ListFilter<Following>, row: FilterRow, context: EvaluationContext<Following>) => boolean;
+//# sourceMappingURL=filter.d.ts.map

package/dist/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"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"}