graphile-connection-filter 1.1.0

package/utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Utility functions for the connection filter plugin.
+ */
+/**
+ * Check if a value is an empty object (no own enumerable keys).
+ */
+export declare function isEmpty(o: unknown): boolean;
+/**
+ * Check if a pgResource is a computed scalar attribute function.
+ * A computed attribute is a function that:
+ * - has parameters
+ * - returns a scalar (no attributes on codec)
+ * - is unique (returns single row)
+ * - first parameter's codec has attributes (i.e. takes a table row)
+ */
+export declare function isComputedScalarAttributeResource(s: any): boolean;
+/**
+ * Get all computed attribute resources for a given source.
+ */
+export declare function getComputedAttributeResources(build: any, source: any): any[];
+/**
+ * Walks from a PgCondition up to the PgSelectQueryBuilder.
+ * Uses the .parent property on PgCondition to traverse up the chain,
+ * following Benjie's pattern from postgraphile-plugin-fulltext-filter.
+ *
+ * This is used by satellite plugins (search, BM25, pgvector) that need
+ * to access the query builder from within a filter's apply callback
+ * to inject SELECT expressions (for ranking/scoring) and ORDER BY clauses.
+ *
+ * @param build - The Graphile Build object (needs build.dataplanPg.PgCondition)
+ * @param $condition - The PgCondition instance from the filter apply callback
+ * @returns The PgSelectQueryBuilder if found, or null
+ */
+export declare function getQueryBuilder(build: GraphileBuild.Build, $condition: any): any | null;
+/**
+ * Creates an assertion function that validates filter input values.
+ *
+ * Rejects empty objects in nested contexts (logical operators, relation filters)
+ * and optionally rejects null literals based on the connectionFilterAllowNullInput option.
+ *
+ * Note: Top-level empty filter `{}` is handled in ConnectionFilterArgPlugin's
+ * applyPlan — it's treated as "no filter" and skipped, not rejected.
+ */
+export declare function makeAssertAllowed(build: any): (value: unknown, mode: 'object' | 'list') => void;

package/utils.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Utility functions for the connection filter plugin.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = isEmpty;
+exports.isComputedScalarAttributeResource = isComputedScalarAttributeResource;
+exports.getComputedAttributeResources = getComputedAttributeResources;
+exports.getQueryBuilder = getQueryBuilder;
+exports.makeAssertAllowed = makeAssertAllowed;
+/**
+ * Check if a value is an empty object (no own enumerable keys).
+ */
+function isEmpty(o) {
+    return typeof o === 'object' && o !== null && Object.keys(o).length === 0;
+}
+/**
+ * Check if a pgResource is a computed scalar attribute function.
+ * A computed attribute is a function that:
+ * - has parameters
+ * - returns a scalar (no attributes on codec)
+ * - is unique (returns single row)
+ * - first parameter's codec has attributes (i.e. takes a table row)
+ */
+function isComputedScalarAttributeResource(s) {
+    if (!s.parameters || s.parameters.length < 1) {
+        return false;
+    }
+    if (s.codec.attributes) {
+        return false;
+    }
+    if (!s.isUnique) {
+        return false;
+    }
+    const firstParameter = s.parameters[0];
+    if (!firstParameter?.codec.attributes) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get all computed attribute resources for a given source.
+ */
+function getComputedAttributeResources(build, source) {
+    const computedAttributeSources = Object.values(build.input.pgRegistry.pgResources).filter((s) => isComputedScalarAttributeResource(s) &&
+        s.parameters[0].codec === source.codec);
+    return computedAttributeSources;
+}
+/**
+ * Walks from a PgCondition up to the PgSelectQueryBuilder.
+ * Uses the .parent property on PgCondition to traverse up the chain,
+ * following Benjie's pattern from postgraphile-plugin-fulltext-filter.
+ *
+ * This is used by satellite plugins (search, BM25, pgvector) that need
+ * to access the query builder from within a filter's apply callback
+ * to inject SELECT expressions (for ranking/scoring) and ORDER BY clauses.
+ *
+ * @param build - The Graphile Build object (needs build.dataplanPg.PgCondition)
+ * @param $condition - The PgCondition instance from the filter apply callback
+ * @returns The PgSelectQueryBuilder if found, or null
+ */
+function getQueryBuilder(build, $condition) {
+    const PgCondition = build.dataplanPg?.PgCondition;
+    if (!PgCondition)
+        return null;
+    let current = $condition;
+    const { alias } = current;
+    // Walk up through nested PgConditions (e.g. and/or/not)
+    // Note: PgCondition.parent is protected, so we use bracket notation
+    // to access it from outside the class hierarchy.
+    while (current &&
+        current instanceof PgCondition &&
+        current.alias === alias) {
+        current = current['parent'];
+    }
+    // Verify we found a query builder with matching alias
+    // Using duck-typing per Benjie's pattern
+    if (current &&
+        typeof current.selectAndReturnIndex === 'function' &&
+        current.alias === alias) {
+        return current;
+    }
+    return null;
+}
+/**
+ * Creates an assertion function that validates filter input values.
+ *
+ * Rejects empty objects in nested contexts (logical operators, relation filters)
+ * and optionally rejects null literals based on the connectionFilterAllowNullInput option.
+ *
+ * Note: Top-level empty filter `{}` is handled in ConnectionFilterArgPlugin's
+ * applyPlan — it's treated as "no filter" and skipped, not rejected.
+ */
+function makeAssertAllowed(build) {
+    const { options, EXPORTABLE } = build;
+    const { connectionFilterAllowNullInput, } = options;
+    const assertAllowed = EXPORTABLE((connectionFilterAllowNullInput, isEmpty) => function (value, mode) {
+        // Reject empty objects in nested filter contexts (and/or/not, relation filters)
+        if (mode === 'object' && isEmpty(value)) {
+            throw Object.assign(new Error('Empty objects are forbidden in filter argument input.'), {});
+        }
+        if (mode === 'list') {
+            const arr = value;
+            if (arr) {
+                const l = arr.length;
+                for (let i = 0; i < l; i++) {
+                    if (isEmpty(arr[i])) {
+                        throw Object.assign(new Error('Empty objects are forbidden in filter argument input.'), {});
+                    }
+                }
+            }
+        }
+        // For all modes, check null
+        if (!connectionFilterAllowNullInput && value === null) {
+            throw Object.assign(new Error('Null literals are forbidden in filter argument input.'), {});
+        }
+    }, [connectionFilterAllowNullInput, isEmpty]);
+    return assertAllowed;
+}