@byline/core 0.9.3

package/dist/query/parse-where.js

@@ -0,0 +1,352 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { fieldTypeToStore } from '../storage/field-store-map.js';
+// ---------------------------------------------------------------------------
+// Document-level reserved keys
+// ---------------------------------------------------------------------------
+/** Where clause keys that map to document-level columns, not EAV stores. */
+const DOCUMENT_LEVEL_KEYS = new Set(['status', 'path', 'query']);
+// ---------------------------------------------------------------------------
+// Document-level sort columns
+// ---------------------------------------------------------------------------
+const DOCUMENT_SORT_COLUMNS = {
+    createdAt: 'created_at',
+    updatedAt: 'updated_at',
+    path: 'path',
+    created_at: 'created_at',
+    updated_at: 'updated_at',
+};
+// ---------------------------------------------------------------------------
+// Parse functions
+// ---------------------------------------------------------------------------
+/**
+ * Parse a client API `where` clause into document-level conditions and
+ * adapter-facing DocumentFilter descriptors. When `ctx` is provided,
+ * nested relation sub-clauses (e.g. `{ category: { path: 'news' } }`)
+ * are resolved into `RelationFilter` entries; otherwise only
+ * direct/operator predicates against the relation's own
+ * `target_document_id` are emitted.
+ */
+export async function parseWhere(where, definition, ctx) {
+    return parseWhereInternal(where, definition, ctx, { isNested: false, inCombinator: false });
+}
+/**
+ * Combine a `beforeRead` hook predicate with a caller-supplied where
+ * clause using implicit AND. Returns whichever side is non-empty, or
+ * wraps both in `$and` when both are present.
+ *
+ * Defined at the predicate level (rather than merging two `ParsedWhere`
+ * outputs) so the result still flows through `parseWhere` once — there
+ * is one normalisation pass and one place where reserved keys, relation
+ * lookups, and combinator flattening happen. `null` is treated the same
+ * as `undefined` (the cache value `null` records "hook ran and applied
+ * no scoping").
+ */
+export function mergePredicates(hookPredicate, userWhere) {
+    if (!hookPredicate && !userWhere)
+        return undefined;
+    if (!hookPredicate)
+        return userWhere;
+    if (!userWhere)
+        return hookPredicate;
+    return { $and: [hookPredicate, userWhere] };
+}
+/**
+ * Recursion entry point. `isNested: true` disables the top-level reserved
+ * keys (`status`, `query`, `path`) so that on a nested sub-where, those
+ * names resolve as ordinary fields on the target collection (where `path`
+ * and `status` are typically real text fields).
+ */
+async function parseWhereInternal(where, definition, ctx, { isNested, inCombinator }) {
+    const result = { filters: [] };
+    if (!where)
+        return result;
+    for (const [key, rawValue] of Object.entries(where)) {
+        // The shared `QueryPredicate` index signature includes `undefined` so it
+        // can coexist with the optional `$and` / `$or` combinator properties;
+        // skip explicit-undefined entries up front so the rest of this loop can
+        // assume a concrete value.
+        if (rawValue === undefined)
+            continue;
+        // --- Boolean combinators ---------------------------------------------
+        // `$and` / `$or` carry an array of child predicates. Each child is
+        // parsed in its own scope (an `$or` child is itself an implicit AND of
+        // its keys); the resulting `DocumentFilter[]` is wrapped in a
+        // CombinatorFilter and added to the outer filter list.
+        //
+        // Top-level `$and` is structurally redundant with the implicit AND
+        // across `result.filters`, so we flatten it: parse each child and
+        // splice its filters in. The combinator only earns its keep when
+        // nested under `$or` (or vice versa). Document-level reserved-key
+        // results (status / query / pathFilter) inside combinators are
+        // intentionally dropped — they don't compose with OR semantics and
+        // belong at the top level of the where clause.
+        if (key === '$and' || key === '$or') {
+            if (!Array.isArray(rawValue)) {
+                ctx?.logger?.debug({ key, collection: definition.path }, 'parse-where: dropping combinator — value is not an array of predicates');
+                continue;
+            }
+            const childFilters = [];
+            for (const child of rawValue) {
+                // Children parse with `inCombinator: true` so reserved keys
+                // (`status`, `path`) become `DocumentColumnFilter` predicates
+                // rather than being intercepted as top-level scalar parameters
+                // — they need to compose with the combinator's OR/AND, which
+                // the top-level scalar form cannot do.
+                const childParsed = await parseWhereInternal(child, definition, ctx, {
+                    isNested,
+                    inCombinator: true,
+                });
+                childFilters.push(childParsed.filters);
+            }
+            if (key === '$and') {
+                // Flatten: AND over [[a, b], [c]] becomes [a, b, c] at the outer
+                // level since the outer scope is itself implicit-AND.
+                for (const group of childFilters)
+                    result.filters.push(...group);
+            }
+            else {
+                // `$or`: each child group is itself implicit-AND, so wrap each
+                // group in an inner `and` combinator (when it has more than one
+                // filter) and emit a single outer `or` combinator over the lot.
+                // Empty child groups (parsed to nothing) are skipped — keeping
+                // them would change semantics ("OR with always-true").
+                const orChildren = [];
+                for (const group of childFilters) {
+                    if (group.length === 0)
+                        continue;
+                    if (group.length === 1) {
+                        orChildren.push(group[0]);
+                    }
+                    else {
+                        orChildren.push({ kind: 'and', children: group });
+                    }
+                }
+                if (orChildren.length > 0) {
+                    result.filters.push({ kind: 'or', children: orChildren });
+                }
+            }
+            continue;
+        }
+        // --- Document-level reserved keys --------------------------------------
+        // At the top level (not nested in a relation, not inside a combinator)
+        // these keys map to direct adapter scalar parameters
+        // (`ParsedWhere.status` / `query` / `pathFilter`) which compile to the
+        // outermost WHERE clause. Inside a combinator that mapping no longer
+        // composes — the predicate needs to OR with siblings, which the scalar
+        // parameter form cannot express — so `status` / `path` downshift to a
+        // `DocumentColumnFilter` and `query` is dropped (text search has no
+        // sensible OR-composing form here).
+        if (!isNested) {
+            if (key === 'status') {
+                if (inCombinator) {
+                    const parsed = normaliseToOperator(rawValue);
+                    if (parsed) {
+                        result.filters.push({
+                            kind: 'docColumn',
+                            column: 'status',
+                            operator: parsed.operator,
+                            value: parsed.value === null ? null : String(parsed.value),
+                        });
+                    }
+                    continue;
+                }
+                if (typeof rawValue === 'string') {
+                    result.status = rawValue;
+                }
+                continue;
+            }
+            if (key === 'query') {
+                if (inCombinator) {
+                    ctx?.logger?.debug({ collection: definition.path }, 'parse-where: dropping `query` inside a combinator — text search does not compose with OR/AND');
+                    continue;
+                }
+                if (typeof rawValue === 'string') {
+                    result.query = rawValue;
+                }
+                continue;
+            }
+            if (key === 'path') {
+                if (inCombinator) {
+                    const parsed = normaliseToOperator(rawValue);
+                    if (parsed) {
+                        result.filters.push({
+                            kind: 'docColumn',
+                            column: 'path',
+                            operator: parsed.operator,
+                            value: parsed.value === null ? null : String(parsed.value),
+                        });
+                    }
+                    continue;
+                }
+                const parsed = normaliseToOperator(rawValue);
+                if (parsed) {
+                    result.pathFilter = {
+                        operator: parsed.operator,
+                        value: String(parsed.value),
+                    };
+                }
+                continue;
+            }
+        }
+        // --- Field-level keys --------------------------------------------------
+        const field = definition.fields.find((f) => f.name === key);
+        if (!field)
+            continue; // Unknown field — skip silently
+        // Relation field with a plain-object sub-clause → cross-collection filter.
+        // A "plain object with no $-prefixed top-level keys" is unambiguously a
+        // nested where; anything else (bare value, operator object) stays in the
+        // ordinary field-filter path below and matches the relation's
+        // target_document_id column directly.
+        if (field.type === 'relation' && isPlainSubWhere(rawValue)) {
+            if (!ctx) {
+                // No way to resolve the target without a ParseContext. Direct
+                // callers of `parseWhere` (tests, tooling) can legitimately hit
+                // this path; CollectionHandle always provides one.
+                continue;
+            }
+            const relation = field;
+            const targetPath = relation.targetCollection;
+            if (!targetPath) {
+                ctx.logger?.debug({ fieldName: key, collection: definition.path }, 'parse-where: dropping nested relation sub-clause — relation field has no targetCollection');
+                continue;
+            }
+            const targetDef = ctx.collections.find((c) => c.path === targetPath);
+            if (!targetDef) {
+                ctx.logger?.debug({ fieldName: key, targetPath, collection: definition.path }, 'parse-where: dropping nested relation sub-clause — target collection not registered');
+                continue;
+            }
+            const targetCollectionId = await ctx.resolveCollectionId(targetPath);
+            const nested = await parseWhereInternal(rawValue, targetDef, ctx, {
+                isNested: true,
+                inCombinator: false,
+            });
+            // Flatten nested: only field-level / relation-level conditions make
+            // sense inside a relation subclause. Document-level keys (status,
+            // path, query) on the target are deliberately out of scope for this
+            // first phase — they can be added later by promoting them into
+            // the nested filter list here.
+            result.filters.push({
+                kind: 'relation',
+                fieldName: key,
+                targetCollectionId,
+                nested: nested.filters,
+            });
+            continue;
+        }
+        const storeInfo = fieldTypeToStore[field.type];
+        if (!storeInfo)
+            continue; // Structure fields can't be filtered directly
+        const parsed = normaliseToOperator(rawValue);
+        if (!parsed)
+            continue;
+        result.filters.push({
+            kind: 'field',
+            fieldName: key,
+            storeType: storeInfo.storeType,
+            valueColumn: storeInfo.valueColumn,
+            operator: parsed.operator,
+            value: parsed.value,
+        });
+    }
+    return result;
+}
+/**
+ * Parse a client API `sort` spec into either a field-level sort descriptor
+ * or a document-level order column.
+ */
+export function parseSort(sort, definition) {
+    if (!sort) {
+        return { orderBy: 'created_at', orderDirection: 'desc' };
+    }
+    const entries = Object.entries(sort);
+    if (entries.length === 0) {
+        return { orderBy: 'created_at', orderDirection: 'desc' };
+    }
+    const [fieldName, direction] = entries[0];
+    // Check if it's a document-level column
+    const docColumn = DOCUMENT_SORT_COLUMNS[fieldName];
+    if (docColumn) {
+        return { orderBy: docColumn, orderDirection: direction };
+    }
+    // Check if it's a collection field
+    const field = definition.fields.find((f) => f.name === fieldName);
+    if (!field) {
+        return { orderBy: 'created_at', orderDirection: 'desc' };
+    }
+    const storeInfo = fieldTypeToStore[field.type];
+    if (!storeInfo) {
+        return { orderBy: 'created_at', orderDirection: 'desc' };
+    }
+    return {
+        fieldSort: {
+            fieldName,
+            storeType: storeInfo.storeType,
+            valueColumn: storeInfo.valueColumn,
+            direction,
+        },
+    };
+}
+/**
+ * Predicate-level combinator keys. These are `$`-prefixed but, unlike
+ * operator keys (`$eq`, `$ne`, …), they are valid inside a "plain
+ * sub-where" because their value is a list of nested predicates rather
+ * than a comparison value.
+ */
+const COMBINATOR_KEYS = new Set(['$and', '$or']);
+/**
+ * A "plain sub-where" is a non-null, non-array object whose top-level keys
+ * are field names or predicate-level combinators (`$and` / `$or`) — but
+ * **not** comparison-operator keys (`$eq`, `$ne`, …). Used to disambiguate
+ * `{ category: { path: 'news' } }` (nested where against the target) from
+ * `{ category: { $eq: 'abc-id' } }` (operator object on the relation's own
+ * `target_document_id`).
+ */
+function isPlainSubWhere(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return false;
+    if (Array.isArray(raw))
+        return false;
+    const keys = Object.keys(raw);
+    // An empty object is not a meaningful sub-where; treat as non-match
+    // (ordinary field-filter path will then reject it via normaliseToOperator).
+    if (keys.length === 0)
+        return false;
+    for (const k of keys) {
+        if (k.startsWith('$') && !COMBINATOR_KEYS.has(k))
+            return false;
+    }
+    return true;
+}
+/**
+ * Normalise a WhereValue (bare value or operator object) into a single
+ * operator + value pair.
+ */
+function normaliseToOperator(raw) {
+    // Bare value → $eq
+    if (raw === null ||
+        typeof raw === 'string' ||
+        typeof raw === 'number' ||
+        typeof raw === 'boolean') {
+        return { operator: '$eq', value: raw };
+    }
+    // Operator object
+    const ops = raw;
+    const operatorEntries = Object.entries(ops);
+    if (operatorEntries.length === 0)
+        return undefined;
+    // Use the first operator found
+    const [op, val] = operatorEntries[0];
+    return {
+        operator: op,
+        value: val,
+    };
+}
+/** Exported for testing. */
+export { DOCUMENT_LEVEL_KEYS, DOCUMENT_SORT_COLUMNS };
+//# sourceMappingURL=parse-where.js.map

package/dist/query/parse-where.js.map

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

package/dist/query/parse-where.test.node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};
+//# sourceMappingURL=parse-where.test.node.d.ts.map

package/dist/query/parse-where.test.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-where.test.node.d.ts","sourceRoot":"","sources":["../../src/query/parse-where.test.node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}