@entifix/core 0.1.0-0

package/dist/rsql/parse-rsql.js

@@ -0,0 +1,235 @@
+import { EntifixBuildError } from '../base-entities/entifix-error/index.js';
+import { RSQL_AND, RSQL_COMPARISON_TOKENS, RSQL_NULL_TOKEN, RSQL_OPERATORS, RSQL_OR, rsqlArity } from './rsql-operators.js';
+/**
+ * Bounds on what an inbound expression may cost us. The URL comes from a
+ * client, so an unbounded parser is a denial-of-service surface: deep nesting
+ * would exhaust the stack and a huge disjunction would become an equally huge
+ * Mongo query.
+ */ const MAX_DEPTH = 16;
+const MAX_NODES = 128;
+const fail = (message, expression)=>new EntifixBuildError(`Invalid RSQL: ${message}`, undefined, {
+        expression
+    });
+/** A property name — the RSQL selector. Kept conservative on purpose. */ const SELECTOR = /^[A-Za-z_][A-Za-z0-9_.-]*/;
+const atEnd = (cursor)=>cursor.index >= cursor.text.length;
+const peek = (cursor)=>cursor.text[cursor.index];
+function skipWhitespace(cursor) {
+    while(!atEnd(cursor) && /\s/.test(cursor.text[cursor.index]))cursor.index++;
+}
+function countNode(cursor) {
+    if (++cursor.nodes > MAX_NODES) {
+        throw fail(`expression exceeds ${MAX_NODES} nodes`, cursor.text);
+    }
+}
+/**
+ * Reads one argument: a quoted string (either quote style, with `\` escapes) or
+ * a bare run of characters up to the next grammar character. The result is
+ * always a string — typing happens later, from metadata.
+ */ function readValue(cursor) {
+    skipWhitespace(cursor);
+    const quoteChar = peek(cursor);
+    if (quoteChar === "'" || quoteChar === '"') {
+        cursor.index++;
+        let value = '';
+        while(!atEnd(cursor)){
+            const char = cursor.text[cursor.index];
+            if (char === '\\') {
+                const escaped = cursor.text[cursor.index + 1];
+                if (escaped === undefined) {
+                    throw fail('expression ends in an escape', cursor.text);
+                }
+                value += escaped;
+                cursor.index += 2;
+                continue;
+            }
+            if (char === quoteChar) {
+                cursor.index++;
+                return value;
+            }
+            value += char;
+            cursor.index++;
+        }
+        throw fail('unterminated quoted value', cursor.text);
+    }
+    const start = cursor.index;
+    while(!atEnd(cursor) && !/[;,()\s]/.test(cursor.text[cursor.index])){
+        cursor.index++;
+    }
+    if (cursor.index === start) {
+        throw fail('missing value', cursor.text);
+    }
+    return cursor.text.slice(start, cursor.index);
+}
+/** Reads `(a,b,…)` — the argument list of `=in=`/`=out=`/`=btn=`/`=nbtn=`. */ function readValueList(cursor) {
+    skipWhitespace(cursor);
+    if (peek(cursor) !== '(') {
+        throw fail('expected a parenthesized value list', cursor.text);
+    }
+    cursor.index++;
+    const values = [];
+    for(;;){
+        values.push(readValue(cursor));
+        skipWhitespace(cursor);
+        const char = peek(cursor);
+        if (char === ',') {
+            cursor.index++;
+            continue;
+        }
+        if (char === ')') {
+            cursor.index++;
+            return values;
+        }
+        throw fail('unterminated value list', cursor.text);
+    }
+}
+/** Matches the longest comparison token at the cursor, or `undefined`. */ function readToken(cursor) {
+    for (const token of RSQL_COMPARISON_TOKENS){
+        if (cursor.text.startsWith(token, cursor.index)) {
+            cursor.index += token.length;
+            return token;
+        }
+    }
+    return undefined;
+}
+function parseComparison(cursor) {
+    countNode(cursor);
+    skipWhitespace(cursor);
+    const selector = SELECTOR.exec(cursor.text.slice(cursor.index));
+    if (!selector) {
+        throw fail(`expected a property name at position ${cursor.index}`, cursor.text);
+    }
+    const property = selector[0];
+    cursor.index += property.length;
+    skipWhitespace(cursor);
+    const token = readToken(cursor);
+    if (!token) {
+        throw fail(`expected an operator after "${property}"`, cursor.text);
+    }
+    if (token === RSQL_NULL_TOKEN) {
+        const argument = readValue(cursor);
+        if (argument !== 'true' && argument !== 'false') {
+            throw fail(`"${RSQL_NULL_TOKEN}" takes true or false`, cursor.text);
+        }
+        return {
+            property,
+            operator: argument === 'true' ? 'isNull' : 'isNotNull'
+        };
+    }
+    const operator = RSQL_OPERATORS[token];
+    switch(rsqlArity(operator)){
+        case 'list':
+            return {
+                property,
+                operator,
+                values: readValueList(cursor)
+            };
+        case 'range':
+            {
+                const bounds = readValueList(cursor);
+                if (bounds.length !== 2) {
+                    throw fail(`"${token}" takes exactly two bounds`, cursor.text);
+                }
+                return {
+                    property,
+                    operator,
+                    start: bounds[0],
+                    end: bounds[1]
+                };
+            }
+        default:
+            return {
+                property,
+                operator,
+                value: readValue(cursor)
+            };
+    }
+}
+/** A comparison, or a parenthesized sub-expression. */ function parsePrimary(cursor, depth) {
+    skipWhitespace(cursor);
+    if (peek(cursor) === '(') {
+        if (depth >= MAX_DEPTH) {
+            throw fail(`nesting deeper than ${MAX_DEPTH} levels`, cursor.text);
+        }
+        cursor.index++;
+        const group = parseOr(cursor, depth + 1);
+        skipWhitespace(cursor);
+        if (peek(cursor) !== ')') {
+            throw fail('unbalanced parenthesis', cursor.text);
+        }
+        cursor.index++;
+        return group;
+    }
+    return parseComparison(cursor);
+}
+/**
+ * Collapses a single-child group into that child, so `a==1` parses to one
+ * comparison rather than three nested wrappers. Keeps the parsed tree
+ * comparable with the one that was serialized.
+ */ function group(operator, values) {
+    return values.length === 1 ? values[0] : {
+        operator,
+        values
+    };
+}
+function parseAnd(cursor, depth) {
+    const values = [
+        parsePrimary(cursor, depth)
+    ];
+    for(;;){
+        skipWhitespace(cursor);
+        if (peek(cursor) !== RSQL_AND) return group('and', values);
+        cursor.index++;
+        values.push(parsePrimary(cursor, depth));
+    }
+}
+function parseOr(cursor, depth) {
+    const values = [
+        parseAnd(cursor, depth)
+    ];
+    for(;;){
+        skipWhitespace(cursor);
+        if (peek(cursor) !== RSQL_OR) return group('or', values);
+        cursor.index++;
+        values.push(parseAnd(cursor, depth));
+    }
+}
+/**
+ * Parses an RSQL expression into a raw (still untyped) filter tree.
+ *
+ * Precedence follows RSQL: `,` (or) binds looser than `;` (and), and
+ * parentheses override both. Values stay strings — {@link coerceFiltering} is
+ * what turns them into the entity's own types, and it is also what checks the
+ * properties against the metadata allowlist. Parsing alone never trusts the
+ * input enough to build a query from it.
+ *
+ * Throws {@link EntifixBuildError} on malformed input, which services surface
+ * as a `400`.
+ */ export function parseRsql(expression) {
+    const trimmed = expression.trim();
+    if (trimmed === '') return {
+        operator: 'and',
+        values: []
+    };
+    const cursor = {
+        text: trimmed,
+        index: 0,
+        nodes: 0
+    };
+    const parsed = parseOr(cursor, 0);
+    skipWhitespace(cursor);
+    if (!atEnd(cursor)) {
+        throw fail(`unexpected "${peek(cursor)}" at position ${cursor.index}`, trimmed);
+    }
+    // The result is always a group, so callers get one shape to walk.
+    return 'property' in parsed ? {
+        operator: 'and',
+        values: [
+            parsed
+        ]
+    } : parsed;
+}
+/** Narrows a raw node to a comparison. */ export function isRawFilter(node) {
+    return 'property' in node;
+}
+
+//# sourceMappingURL=parse-rsql.js.map

package/dist/rsql/parse-rsql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/parse-rsql.ts"],"sourcesContent":["import { EntifixBuildError } from '../base-entities/entifix-error/index.js';\nimport {\n  RSQL_AND,\n  RSQL_COMPARISON_TOKENS,\n  RSQL_NULL_TOKEN,\n  RSQL_OPERATORS,\n  RSQL_OR,\n  rsqlArity,\n  type RsqlOperator,\n} from './rsql-operators.js';\n\n/**\n * A parsed filter before coercion: identical to an {@link EntityFilter} except\n * every argument is still the raw string the URL carried. Re-typing needs the\n * entity's metadata, which this parser deliberately does not have — see\n * `coerce-rsql`.\n */\nexport type RawFilter = {\n  property: string;\n  operator: RsqlOperator;\n  value?: string;\n  values?: string[];\n  start?: string;\n  end?: string;\n};\n\nexport type RawFilterGroup = {\n  operator: 'and' | 'or';\n  values: Array<RawFilter | RawFilterGroup>;\n};\n\n/**\n * Bounds on what an inbound expression may cost us. The URL comes from a\n * client, so an unbounded parser is a denial-of-service surface: deep nesting\n * would exhaust the stack and a huge disjunction would become an equally huge\n * Mongo query.\n */\nconst MAX_DEPTH = 16;\nconst MAX_NODES = 128;\n\nconst fail = (message: string, expression: string) =>\n  new EntifixBuildError(`Invalid RSQL: ${message}`, undefined, { expression });\n\n/** A property name — the RSQL selector. Kept conservative on purpose. */\nconst SELECTOR = /^[A-Za-z_][A-Za-z0-9_.-]*/;\n\ninterface Cursor {\n  readonly text: string;\n  index: number;\n  nodes: number;\n}\n\nconst atEnd = (cursor: Cursor) => cursor.index >= cursor.text.length;\n\nconst peek = (cursor: Cursor) => cursor.text[cursor.index];\n\nfunction skipWhitespace(cursor: Cursor): void {\n  while (!atEnd(cursor) && /\\s/.test(cursor.text[cursor.index])) cursor.index++;\n}\n\nfunction countNode(cursor: Cursor): void {\n  if (++cursor.nodes > MAX_NODES) {\n    throw fail(`expression exceeds ${MAX_NODES} nodes`, cursor.text);\n  }\n}\n\n/**\n * Reads one argument: a quoted string (either quote style, with `\\` escapes) or\n * a bare run of characters up to the next grammar character. The result is\n * always a string — typing happens later, from metadata.\n */\nfunction readValue(cursor: Cursor): string {\n  skipWhitespace(cursor);\n  const quoteChar = peek(cursor);\n\n  if (quoteChar === \"'\" || quoteChar === '\"') {\n    cursor.index++;\n    let value = '';\n    while (!atEnd(cursor)) {\n      const char = cursor.text[cursor.index];\n      if (char === '\\\\') {\n        const escaped = cursor.text[cursor.index + 1];\n        if (escaped === undefined) {\n          throw fail('expression ends in an escape', cursor.text);\n        }\n        value += escaped;\n        cursor.index += 2;\n        continue;\n      }\n      if (char === quoteChar) {\n        cursor.index++;\n        return value;\n      }\n      value += char;\n      cursor.index++;\n    }\n    throw fail('unterminated quoted value', cursor.text);\n  }\n\n  const start = cursor.index;\n  while (!atEnd(cursor) && !/[;,()\\s]/.test(cursor.text[cursor.index])) {\n    cursor.index++;\n  }\n  if (cursor.index === start) {\n    throw fail('missing value', cursor.text);\n  }\n  return cursor.text.slice(start, cursor.index);\n}\n\n/** Reads `(a,b,…)` — the argument list of `=in=`/`=out=`/`=btn=`/`=nbtn=`. */\nfunction readValueList(cursor: Cursor): string[] {\n  skipWhitespace(cursor);\n  if (peek(cursor) !== '(') {\n    throw fail('expected a parenthesized value list', cursor.text);\n  }\n  cursor.index++;\n\n  const values: string[] = [];\n  for (;;) {\n    values.push(readValue(cursor));\n    skipWhitespace(cursor);\n    const char = peek(cursor);\n    if (char === ',') {\n      cursor.index++;\n      continue;\n    }\n    if (char === ')') {\n      cursor.index++;\n      return values;\n    }\n    throw fail('unterminated value list', cursor.text);\n  }\n}\n\n/** Matches the longest comparison token at the cursor, or `undefined`. */\nfunction readToken(cursor: Cursor): string | undefined {\n  for (const token of RSQL_COMPARISON_TOKENS) {\n    if (cursor.text.startsWith(token, cursor.index)) {\n      cursor.index += token.length;\n      return token;\n    }\n  }\n  return undefined;\n}\n\nfunction parseComparison(cursor: Cursor): RawFilter {\n  countNode(cursor);\n  skipWhitespace(cursor);\n\n  const selector = SELECTOR.exec(cursor.text.slice(cursor.index));\n  if (!selector) {\n    throw fail(\n      `expected a property name at position ${cursor.index}`,\n      cursor.text,\n    );\n  }\n  const property = selector[0];\n  cursor.index += property.length;\n\n  skipWhitespace(cursor);\n  const token = readToken(cursor);\n  if (!token) {\n    throw fail(`expected an operator after \"${property}\"`, cursor.text);\n  }\n\n  if (token === RSQL_NULL_TOKEN) {\n    const argument = readValue(cursor);\n    if (argument !== 'true' && argument !== 'false') {\n      throw fail(`\"${RSQL_NULL_TOKEN}\" takes true or false`, cursor.text);\n    }\n    return {\n      property,\n      operator: argument === 'true' ? 'isNull' : 'isNotNull',\n    };\n  }\n\n  const operator = RSQL_OPERATORS[token];\n\n  switch (rsqlArity(operator)) {\n    case 'list':\n      return { property, operator, values: readValueList(cursor) };\n    case 'range': {\n      const bounds = readValueList(cursor);\n      if (bounds.length !== 2) {\n        throw fail(`\"${token}\" takes exactly two bounds`, cursor.text);\n      }\n      return { property, operator, start: bounds[0], end: bounds[1] };\n    }\n    default:\n      return { property, operator, value: readValue(cursor) };\n  }\n}\n\n/** A comparison, or a parenthesized sub-expression. */\nfunction parsePrimary(\n  cursor: Cursor,\n  depth: number,\n): RawFilter | RawFilterGroup {\n  skipWhitespace(cursor);\n\n  if (peek(cursor) === '(') {\n    if (depth >= MAX_DEPTH) {\n      throw fail(`nesting deeper than ${MAX_DEPTH} levels`, cursor.text);\n    }\n    cursor.index++;\n    const group = parseOr(cursor, depth + 1);\n    skipWhitespace(cursor);\n    if (peek(cursor) !== ')') {\n      throw fail('unbalanced parenthesis', cursor.text);\n    }\n    cursor.index++;\n    return group;\n  }\n\n  return parseComparison(cursor);\n}\n\n/**\n * Collapses a single-child group into that child, so `a==1` parses to one\n * comparison rather than three nested wrappers. Keeps the parsed tree\n * comparable with the one that was serialized.\n */\nfunction group(\n  operator: 'and' | 'or',\n  values: Array<RawFilter | RawFilterGroup>,\n): RawFilter | RawFilterGroup {\n  return values.length === 1 ? values[0] : { operator, values };\n}\n\nfunction parseAnd(cursor: Cursor, depth: number): RawFilter | RawFilterGroup {\n  const values = [parsePrimary(cursor, depth)];\n  for (;;) {\n    skipWhitespace(cursor);\n    if (peek(cursor) !== RSQL_AND) return group('and', values);\n    cursor.index++;\n    values.push(parsePrimary(cursor, depth));\n  }\n}\n\nfunction parseOr(cursor: Cursor, depth: number): RawFilter | RawFilterGroup {\n  const values = [parseAnd(cursor, depth)];\n  for (;;) {\n    skipWhitespace(cursor);\n    if (peek(cursor) !== RSQL_OR) return group('or', values);\n    cursor.index++;\n    values.push(parseAnd(cursor, depth));\n  }\n}\n\n/**\n * Parses an RSQL expression into a raw (still untyped) filter tree.\n *\n * Precedence follows RSQL: `,` (or) binds looser than `;` (and), and\n * parentheses override both. Values stay strings — {@link coerceFiltering} is\n * what turns them into the entity's own types, and it is also what checks the\n * properties against the metadata allowlist. Parsing alone never trusts the\n * input enough to build a query from it.\n *\n * Throws {@link EntifixBuildError} on malformed input, which services surface\n * as a `400`.\n */\nexport function parseRsql(expression: string): RawFilterGroup {\n  const trimmed = expression.trim();\n  if (trimmed === '') return { operator: 'and', values: [] };\n\n  const cursor: Cursor = { text: trimmed, index: 0, nodes: 0 };\n  const parsed = parseOr(cursor, 0);\n\n  skipWhitespace(cursor);\n  if (!atEnd(cursor)) {\n    throw fail(\n      `unexpected \"${peek(cursor)}\" at position ${cursor.index}`,\n      trimmed,\n    );\n  }\n\n  // The result is always a group, so callers get one shape to walk.\n  return 'property' in parsed ? { operator: 'and', values: [parsed] } : parsed;\n}\n\n/** Narrows a raw node to a comparison. */\nexport function isRawFilter(\n  node: RawFilter | RawFilterGroup,\n): node is RawFilter {\n  return 'property' in node;\n}\n"],"names":["EntifixBuildError","RSQL_AND","RSQL_COMPARISON_TOKENS","RSQL_NULL_TOKEN","RSQL_OPERATORS","RSQL_OR","rsqlArity","MAX_DEPTH","MAX_NODES","fail","message","expression","undefined","SELECTOR","atEnd","cursor","index","text","length","peek","skipWhitespace","test","countNode","nodes","readValue","quoteChar","value","char","escaped","start","slice","readValueList","values","push","readToken","token","startsWith","parseComparison","selector","exec","property","argument","operator","bounds","end","parsePrimary","depth","group","parseOr","parseAnd","parseRsql","trimmed","trim","parsed","isRawFilter","node"],"mappings":"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"}

package/dist/rsql/rsql-operators.d.ts

@@ -0,0 +1,36 @@
+import { EntityFilterArrayOperators, EntityFilterNullOperators, EntityFilterRangeOperators, EntityFilterStringOperators } from '../types/EntityFiltering.js';
+/** Every operator an `EntityFilter` can carry, flattened across its variants. */
+export type RsqlOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | (typeof EntityFilterArrayOperators)[number] | (typeof EntityFilterRangeOperators)[number] | (typeof EntityFilterStringOperators)[number] | (typeof EntityFilterNullOperators)[number];
+/**
+ * The RSQL token each operator is written as. `==`/`!=`/`=gt=`/`=ge=`/`=lt=`/
+ * `=le=`/`=in=`/`=out=` are standard RSQL; the rest are entifix extensions,
+ * named in the same `=word=` shape so a generic RSQL tokenizer still splits
+ * them correctly.
+ *
+ * `isNull`/`isNotNull` share the `=isnull=` token and are told apart by their
+ * boolean argument, because RSQL has no unary comparison.
+ */
+export declare const RSQL_TOKENS: Record<RsqlOperator, string>;
+/**
+ * Token → operator. `=isnull=` is absent on purpose: it maps to two operators,
+ * so the parser resolves it from the argument instead.
+ */
+export declare const RSQL_OPERATORS: Record<string, RsqlOperator>;
+/** The token shared by `isNull`/`isNotNull`. */
+export declare const RSQL_NULL_TOKEN = "=isnull=";
+/**
+ * Comparison tokens ordered longest-first. The tokenizer matches greedily, so
+ * `=nbtn=` must be tried before any shorter token it starts with; scanning this
+ * list in order is what makes that safe as tokens are added.
+ */
+export declare const RSQL_COMPARISON_TOKENS: readonly string[];
+/**
+ * How many arguments an operator's RSQL form carries: `none` still writes a
+ * boolean argument (see `=isnull=`), `list` and `range` write a parenthesized
+ * group, `single` a bare value.
+ */
+export declare function rsqlArity(operator: RsqlOperator): 'none' | 'single' | 'list' | 'range';
+/** Logic operator → its RSQL separator. */
+export declare const RSQL_AND = ";";
+export declare const RSQL_OR = ",";
+//# sourceMappingURL=rsql-operators.d.ts.map

package/dist/rsql/rsql-operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsql-operators.d.ts","sourceRoot":"","sources":["../../src/rsql/rsql-operators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,6BAA6B,CAAC;AAErC,iFAAiF;AACjF,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,GAC3C,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,GAC3C,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,GAC5C,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAepD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAavD,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,eAAe,aAAa,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAGD,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,YAAY,GACrB,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAQtC;AAED,2CAA2C;AAC3C,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,OAAO,MAAM,CAAC"}

package/dist/rsql/rsql-operators.js

@@ -0,0 +1,65 @@
+import { EntityFilterArrayOperators, EntityFilterNullOperators, EntityFilterRangeOperators } from '../types/EntityFiltering.js';
+/**
+ * The RSQL token each operator is written as. `==`/`!=`/`=gt=`/`=ge=`/`=lt=`/
+ * `=le=`/`=in=`/`=out=` are standard RSQL; the rest are entifix extensions,
+ * named in the same `=word=` shape so a generic RSQL tokenizer still splits
+ * them correctly.
+ *
+ * `isNull`/`isNotNull` share the `=isnull=` token and are told apart by their
+ * boolean argument, because RSQL has no unary comparison.
+ */ export const RSQL_TOKENS = {
+    eq: '==',
+    ne: '!=',
+    gt: '=gt=',
+    gte: '=ge=',
+    lt: '=lt=',
+    lte: '=le=',
+    in: '=in=',
+    nin: '=out=',
+    between: '=btn=',
+    nbetween: '=nbtn=',
+    like: '=like=',
+    nlike: '=nlike=',
+    isNull: '=isnull=',
+    isNotNull: '=isnull='
+};
+/**
+ * Token → operator. `=isnull=` is absent on purpose: it maps to two operators,
+ * so the parser resolves it from the argument instead.
+ */ export const RSQL_OPERATORS = {
+    '==': 'eq',
+    '!=': 'ne',
+    '=gt=': 'gt',
+    '=ge=': 'gte',
+    '=lt=': 'lt',
+    '=le=': 'lte',
+    '=in=': 'in',
+    '=out=': 'nin',
+    '=btn=': 'between',
+    '=nbtn=': 'nbetween',
+    '=like=': 'like',
+    '=nlike=': 'nlike'
+};
+/** The token shared by `isNull`/`isNotNull`. */ export const RSQL_NULL_TOKEN = '=isnull=';
+/**
+ * Comparison tokens ordered longest-first. The tokenizer matches greedily, so
+ * `=nbtn=` must be tried before any shorter token it starts with; scanning this
+ * list in order is what makes that safe as tokens are added.
+ */ export const RSQL_COMPARISON_TOKENS = [
+    ...Object.keys(RSQL_OPERATORS),
+    RSQL_NULL_TOKEN
+].sort((left, right)=>right.length - left.length);
+/**
+ * How many arguments an operator's RSQL form carries: `none` still writes a
+ * boolean argument (see `=isnull=`), `list` and `range` write a parenthesized
+ * group, `single` a bare value.
+ */ export function rsqlArity(operator) {
+    if (EntityFilterNullOperators.includes(operator)) return 'none';
+    if (EntityFilterRangeOperators.includes(operator)) return 'range';
+    if (EntityFilterArrayOperators.includes(operator)) return 'list';
+    return 'single';
+}
+/** Logic operator → its RSQL separator. */ export const RSQL_AND = ';';
+export const RSQL_OR = ',';
+
+//# sourceMappingURL=rsql-operators.js.map

package/dist/rsql/rsql-operators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/rsql-operators.ts"],"sourcesContent":["import {\n  EntityFilterArrayOperators,\n  EntityFilterNullOperators,\n  EntityFilterRangeOperators,\n  EntityFilterStringOperators,\n} from '../types/EntityFiltering.js';\n\n/** Every operator an `EntityFilter` can carry, flattened across its variants. */\nexport type RsqlOperator =\n  | 'eq'\n  | 'ne'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | (typeof EntityFilterArrayOperators)[number]\n  | (typeof EntityFilterRangeOperators)[number]\n  | (typeof EntityFilterStringOperators)[number]\n  | (typeof EntityFilterNullOperators)[number];\n\n/**\n * The RSQL token each operator is written as. `==`/`!=`/`=gt=`/`=ge=`/`=lt=`/\n * `=le=`/`=in=`/`=out=` are standard RSQL; the rest are entifix extensions,\n * named in the same `=word=` shape so a generic RSQL tokenizer still splits\n * them correctly.\n *\n * `isNull`/`isNotNull` share the `=isnull=` token and are told apart by their\n * boolean argument, because RSQL has no unary comparison.\n */\nexport const RSQL_TOKENS: Record<RsqlOperator, string> = {\n  eq: '==',\n  ne: '!=',\n  gt: '=gt=',\n  gte: '=ge=',\n  lt: '=lt=',\n  lte: '=le=',\n  in: '=in=',\n  nin: '=out=',\n  between: '=btn=',\n  nbetween: '=nbtn=',\n  like: '=like=',\n  nlike: '=nlike=',\n  isNull: '=isnull=',\n  isNotNull: '=isnull=',\n};\n\n/**\n * Token → operator. `=isnull=` is absent on purpose: it maps to two operators,\n * so the parser resolves it from the argument instead.\n */\nexport const RSQL_OPERATORS: Record<string, RsqlOperator> = {\n  '==': 'eq',\n  '!=': 'ne',\n  '=gt=': 'gt',\n  '=ge=': 'gte',\n  '=lt=': 'lt',\n  '=le=': 'lte',\n  '=in=': 'in',\n  '=out=': 'nin',\n  '=btn=': 'between',\n  '=nbtn=': 'nbetween',\n  '=like=': 'like',\n  '=nlike=': 'nlike',\n};\n\n/** The token shared by `isNull`/`isNotNull`. */\nexport const RSQL_NULL_TOKEN = '=isnull=';\n\n/**\n * Comparison tokens ordered longest-first. The tokenizer matches greedily, so\n * `=nbtn=` must be tried before any shorter token it starts with; scanning this\n * list in order is what makes that safe as tokens are added.\n */\nexport const RSQL_COMPARISON_TOKENS: readonly string[] = [\n  ...Object.keys(RSQL_OPERATORS),\n  RSQL_NULL_TOKEN,\n].sort((left, right) => right.length - left.length);\n\n/**\n * How many arguments an operator's RSQL form carries: `none` still writes a\n * boolean argument (see `=isnull=`), `list` and `range` write a parenthesized\n * group, `single` a bare value.\n */\nexport function rsqlArity(\n  operator: RsqlOperator,\n): 'none' | 'single' | 'list' | 'range' {\n  if ((EntityFilterNullOperators as readonly string[]).includes(operator))\n    return 'none';\n  if ((EntityFilterRangeOperators as readonly string[]).includes(operator))\n    return 'range';\n  if ((EntityFilterArrayOperators as readonly string[]).includes(operator))\n    return 'list';\n  return 'single';\n}\n\n/** Logic operator → its RSQL separator. */\nexport const RSQL_AND = ';';\nexport const RSQL_OR = ',';\n"],"names":["EntityFilterArrayOperators","EntityFilterNullOperators","EntityFilterRangeOperators","RSQL_TOKENS","eq","ne","gt","gte","lt","lte","in","nin","between","nbetween","like","nlike","isNull","isNotNull","RSQL_OPERATORS","RSQL_NULL_TOKEN","RSQL_COMPARISON_TOKENS","Object","keys","sort","left","right","length","rsqlArity","operator","includes","RSQL_AND","RSQL_OR"],"mappings":"AAAA,SACEA,0BAA0B,EAC1BC,yBAAyB,EACzBC,0BAA0B,QAErB,8BAA8B;AAerC;;;;;;;;CAQC,GACD,OAAO,MAAMC,cAA4C;IACvDC,IAAI;IACJC,IAAI;IACJC,IAAI;IACJC,KAAK;IACLC,IAAI;IACJC,KAAK;IACLC,IAAI;IACJC,KAAK;IACLC,SAAS;IACTC,UAAU;IACVC,MAAM;IACNC,OAAO;IACPC,QAAQ;IACRC,WAAW;AACb,EAAE;AAEF;;;CAGC,GACD,OAAO,MAAMC,iBAA+C;IAC1D,MAAM;IACN,MAAM;IACN,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,SAAS;IACT,UAAU;IACV,UAAU;IACV,WAAW;AACb,EAAE;AAEF,8CAA8C,GAC9C,OAAO,MAAMC,kBAAkB,WAAW;AAE1C;;;;CAIC,GACD,OAAO,MAAMC,yBAA4C;OACpDC,OAAOC,IAAI,CAACJ;IACfC;CACD,CAACI,IAAI,CAAC,CAACC,MAAMC,QAAUA,MAAMC,MAAM,GAAGF,KAAKE,MAAM,EAAE;AAEpD;;;;CAIC,GACD,OAAO,SAASC,UACdC,QAAsB;IAEtB,IAAI,AAAC3B,0BAAgD4B,QAAQ,CAACD,WAC5D,OAAO;IACT,IAAI,AAAC1B,2BAAiD2B,QAAQ,CAACD,WAC7D,OAAO;IACT,IAAI,AAAC5B,2BAAiD6B,QAAQ,CAACD,WAC7D,OAAO;IACT,OAAO;AACT;AAEA,yCAAyC,GACzC,OAAO,MAAME,WAAW,IAAI;AAC5B,OAAO,MAAMC,UAAU,IAAI"}

package/dist/rsql/rsql-values.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Writes a value as an RSQL argument. Numbers and booleans go out bare (that is
+ * how RSQL is normally read by a human or another implementation); everything
+ * else is single-quoted, which is also the only way a value containing a
+ * separator can survive the round trip.
+ *
+ * Dates are written as ISO-8601 — the one lossless textual form, and the one
+ * the coercion step parses back.
+ */
+export declare function encodeRsqlValue(value: unknown): string;
+//# sourceMappingURL=rsql-values.d.ts.map

package/dist/rsql/rsql-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsql-values.d.ts","sourceRoot":"","sources":["../../src/rsql/rsql-values.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAStD"}

package/dist/rsql/rsql-values.js

@@ -0,0 +1,26 @@
+/**
+ * Characters that would otherwise be read as grammar. A value containing any of
+ * them has to be quoted, or the tokenizer would split the expression inside it.
+ */ const RESERVED = /[\s;,()'"=!<>\\]/;
+/**
+ * Writes a value as an RSQL argument. Numbers and booleans go out bare (that is
+ * how RSQL is normally read by a human or another implementation); everything
+ * else is single-quoted, which is also the only way a value containing a
+ * separator can survive the round trip.
+ *
+ * Dates are written as ISO-8601 — the one lossless textual form, and the one
+ * the coercion step parses back.
+ */ export function encodeRsqlValue(value) {
+    if (value === null || value === undefined) return "''";
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (value instanceof Date) return quote(value.toISOString());
+    const text = String(value);
+    return text === '' || RESERVED.test(text) ? quote(text) : text;
+}
+/** Single-quotes a value, escaping the quote and the escape character itself. */ function quote(text) {
+    return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+//# sourceMappingURL=rsql-values.js.map

package/dist/rsql/rsql-values.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/rsql-values.ts"],"sourcesContent":["/**\n * Characters that would otherwise be read as grammar. A value containing any of\n * them has to be quoted, or the tokenizer would split the expression inside it.\n */\nconst RESERVED = /[\\s;,()'\"=!<>\\\\]/;\n\n/**\n * Writes a value as an RSQL argument. Numbers and booleans go out bare (that is\n * how RSQL is normally read by a human or another implementation); everything\n * else is single-quoted, which is also the only way a value containing a\n * separator can survive the round trip.\n *\n * Dates are written as ISO-8601 — the one lossless textual form, and the one\n * the coercion step parses back.\n */\nexport function encodeRsqlValue(value: unknown): string {\n  if (value === null || value === undefined) return \"''\";\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (value instanceof Date) return quote(value.toISOString());\n\n  const text = String(value);\n  return text === '' || RESERVED.test(text) ? quote(text) : text;\n}\n\n/** Single-quotes a value, escaping the quote and the escape character itself. */\nfunction quote(text: string): string {\n  return `'${text.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")}'`;\n}\n"],"names":["RESERVED","encodeRsqlValue","value","undefined","String","Date","quote","toISOString","text","test","replace"],"mappings":"AAAA;;;CAGC,GACD,MAAMA,WAAW;AAEjB;;;;;;;;CAQC,GACD,OAAO,SAASC,gBAAgBC,KAAc;IAC5C,IAAIA,UAAU,QAAQA,UAAUC,WAAW,OAAO;IAClD,IAAI,OAAOD,UAAU,YAAY,OAAOA,UAAU,WAAW;QAC3D,OAAOE,OAAOF;IAChB;IACA,IAAIA,iBAAiBG,MAAM,OAAOC,MAAMJ,MAAMK,WAAW;IAEzD,MAAMC,OAAOJ,OAAOF;IACpB,OAAOM,SAAS,MAAMR,SAASS,IAAI,CAACD,QAAQF,MAAME,QAAQA;AAC5D;AAEA,+EAA+E,GAC/E,SAASF,MAAME,IAAY;IACzB,OAAO,CAAC,CAAC,EAAEA,KAAKE,OAAO,CAAC,OAAO,QAAQA,OAAO,CAAC,MAAM,OAAO,CAAC,CAAC;AAChE"}

package/dist/rsql/serialize-rsql.d.ts

@@ -0,0 +1,19 @@
+import type { Entity } from '../types/Entity.js';
+import type { EntityFilter, EntityFiltering, FilterGroup } from '../types/EntityFiltering.js';
+/**
+ * A group carries `values` + a logic operator and, unlike the array filter, has
+ * no `property`. Same discriminator the Mongo `filter-translator` uses — the
+ * two must agree on what counts as a group or a filter would translate one way
+ * and serialize another.
+ */
+export declare function isFilterGroup<TEntity extends Entity>(node: EntityFilter<TEntity> | FilterGroup<TEntity>): node is FilterGroup<TEntity>;
+/**
+ * Serializes an {@link EntityLoadRequest}'s `filtering` into an RSQL
+ * expression. Every top-level entry is joined with `;` (and), mirroring how
+ * `translateFiltering` combines them with `$and` on the Mongo side.
+ *
+ * An absent, empty, or wholly-empty filtering yields `''`, which callers omit
+ * from the URL entirely rather than sending an empty parameter.
+ */
+export declare function serializeRsql<TEntity extends Entity>(filtering?: EntityFiltering<TEntity>[]): string;
+//# sourceMappingURL=serialize-rsql.d.ts.map

package/dist/rsql/serialize-rsql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-rsql.d.ts","sourceRoot":"","sources":["../../src/rsql/serialize-rsql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,WAAW,EAEZ,MAAM,6BAA6B,CAAC;AAUrC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,EAClD,IAAI,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,GACjD,IAAI,IAAI,WAAW,CAAC,OAAO,CAAC,CAI9B;AA0DD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,EAClD,SAAS,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACrC,MAAM,CAaR"}

package/dist/rsql/serialize-rsql.js

@@ -0,0 +1,71 @@
+import { RSQL_AND, RSQL_OR, RSQL_TOKENS, rsqlArity } from './rsql-operators.js';
+import { encodeRsqlValue } from './rsql-values.js';
+/**
+ * A group carries `values` + a logic operator and, unlike the array filter, has
+ * no `property`. Same discriminator the Mongo `filter-translator` uses — the
+ * two must agree on what counts as a group or a filter would translate one way
+ * and serialize another.
+ */ export function isFilterGroup(node) {
+    return !('property' in node) && (node.operator === 'and' || node.operator === 'or');
+}
+const separatorFor = (operator)=>operator === 'or' ? RSQL_OR : RSQL_AND;
+/** `isNull`/`isNotNull` share one token, told apart by their boolean argument. */ const nullArgument = (operator)=>operator === 'isNull' ? 'true' : 'false';
+function serializeComparison(filter) {
+    const operator = filter.operator;
+    const property = String(filter.property);
+    const token = RSQL_TOKENS[operator];
+    switch(rsqlArity(operator)){
+        case 'none':
+            return `${property}${token}${nullArgument(operator)}`;
+        case 'list':
+            {
+                const { values } = filter;
+                return `${property}${token}(${values.map(encodeRsqlValue).join(',')})`;
+            }
+        case 'range':
+            {
+                const { start, end } = filter;
+                return `${property}${token}(${encodeRsqlValue(start)},${encodeRsqlValue(end)})`;
+            }
+        default:
+            {
+                const { value } = filter;
+                return `${property}${token}${encodeRsqlValue(value)}`;
+            }
+    }
+}
+/**
+ * Serializes one node. `parent` is the logic operator this node's text will sit
+ * inside: a group only needs parentheses when its own operator differs, since
+ * `;` and `,` already read left-to-right within one operator.
+ */ function serializeNode(node, parent) {
+    if (!isFilterGroup(node)) return serializeComparison(node);
+    const parts = node.values.map((child)=>serializeNode(child, node.operator)).filter((part)=>part !== '');
+    if (parts.length === 0) return '';
+    const text = parts.join(separatorFor(node.operator));
+    const needsParentheses = parts.length > 1 && parent !== undefined && parent !== node.operator;
+    return needsParentheses ? `(${text})` : text;
+}
+/**
+ * Serializes an {@link EntityLoadRequest}'s `filtering` into an RSQL
+ * expression. Every top-level entry is joined with `;` (and), mirroring how
+ * `translateFiltering` combines them with `$and` on the Mongo side.
+ *
+ * An absent, empty, or wholly-empty filtering yields `''`, which callers omit
+ * from the URL entirely rather than sending an empty parameter.
+ */ export function serializeRsql(filtering) {
+    if (!filtering || filtering.length === 0) return '';
+    const parts = [];
+    for (const entry of filtering){
+        const nodes = Array.isArray(entry) ? entry : [
+            entry
+        ];
+        for (const node of nodes){
+            const text = serializeNode(node, 'and');
+            if (text !== '') parts.push(text);
+        }
+    }
+    return parts.join(RSQL_AND);
+}
+
+//# sourceMappingURL=serialize-rsql.js.map

package/dist/rsql/serialize-rsql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/serialize-rsql.ts"],"sourcesContent":["import type { Entity } from '../types/Entity.js';\nimport type {\n  EntityFilter,\n  EntityFiltering,\n  FilterGroup,\n  LogicOperator,\n} from '../types/EntityFiltering.js';\nimport {\n  RSQL_AND,\n  RSQL_OR,\n  RSQL_TOKENS,\n  rsqlArity,\n  type RsqlOperator,\n} from './rsql-operators.js';\nimport { encodeRsqlValue } from './rsql-values.js';\n\n/**\n * A group carries `values` + a logic operator and, unlike the array filter, has\n * no `property`. Same discriminator the Mongo `filter-translator` uses — the\n * two must agree on what counts as a group or a filter would translate one way\n * and serialize another.\n */\nexport function isFilterGroup<TEntity extends Entity>(\n  node: EntityFilter<TEntity> | FilterGroup<TEntity>,\n): node is FilterGroup<TEntity> {\n  return (\n    !('property' in node) && (node.operator === 'and' || node.operator === 'or')\n  );\n}\n\nconst separatorFor = (operator: LogicOperator) =>\n  operator === 'or' ? RSQL_OR : RSQL_AND;\n\n/** `isNull`/`isNotNull` share one token, told apart by their boolean argument. */\nconst nullArgument = (operator: RsqlOperator) =>\n  operator === 'isNull' ? 'true' : 'false';\n\nfunction serializeComparison<TEntity extends Entity>(\n  filter: EntityFilter<TEntity>,\n): string {\n  const operator = filter.operator as RsqlOperator;\n  const property = String(filter.property);\n  const token = RSQL_TOKENS[operator];\n\n  switch (rsqlArity(operator)) {\n    case 'none':\n      return `${property}${token}${nullArgument(operator)}`;\n    case 'list': {\n      const { values } = filter as { values: unknown[] };\n      return `${property}${token}(${values.map(encodeRsqlValue).join(',')})`;\n    }\n    case 'range': {\n      const { start, end } = filter as { start: unknown; end: unknown };\n      return `${property}${token}(${encodeRsqlValue(start)},${encodeRsqlValue(end)})`;\n    }\n    default: {\n      const { value } = filter as { value: unknown };\n      return `${property}${token}${encodeRsqlValue(value)}`;\n    }\n  }\n}\n\n/**\n * Serializes one node. `parent` is the logic operator this node's text will sit\n * inside: a group only needs parentheses when its own operator differs, since\n * `;` and `,` already read left-to-right within one operator.\n */\nfunction serializeNode<TEntity extends Entity>(\n  node: EntityFilter<TEntity> | FilterGroup<TEntity>,\n  parent?: LogicOperator,\n): string {\n  if (!isFilterGroup(node)) return serializeComparison(node);\n\n  const parts = node.values\n    .map(child => serializeNode(child, node.operator))\n    .filter(part => part !== '');\n\n  if (parts.length === 0) return '';\n\n  const text = parts.join(separatorFor(node.operator));\n  const needsParentheses =\n    parts.length > 1 && parent !== undefined && parent !== node.operator;\n\n  return needsParentheses ? `(${text})` : text;\n}\n\n/**\n * Serializes an {@link EntityLoadRequest}'s `filtering` into an RSQL\n * expression. Every top-level entry is joined with `;` (and), mirroring how\n * `translateFiltering` combines them with `$and` on the Mongo side.\n *\n * An absent, empty, or wholly-empty filtering yields `''`, which callers omit\n * from the URL entirely rather than sending an empty parameter.\n */\nexport function serializeRsql<TEntity extends Entity>(\n  filtering?: EntityFiltering<TEntity>[],\n): string {\n  if (!filtering || filtering.length === 0) return '';\n\n  const parts: string[] = [];\n  for (const entry of filtering) {\n    const nodes = Array.isArray(entry) ? entry : [entry];\n    for (const node of nodes) {\n      const text = serializeNode(node, 'and');\n      if (text !== '') parts.push(text);\n    }\n  }\n\n  return parts.join(RSQL_AND);\n}\n"],"names":["RSQL_AND","RSQL_OR","RSQL_TOKENS","rsqlArity","encodeRsqlValue","isFilterGroup","node","operator","separatorFor","nullArgument","serializeComparison","filter","property","String","token","values","map","join","start","end","value","serializeNode","parent","parts","child","part","length","text","needsParentheses","undefined","serializeRsql","filtering","entry","nodes","Array","isArray","push"],"mappings":"AAOA,SACEA,QAAQ,EACRC,OAAO,EACPC,WAAW,EACXC,SAAS,QAEJ,sBAAsB;AAC7B,SAASC,eAAe,QAAQ,mBAAmB;AAEnD;;;;;CAKC,GACD,OAAO,SAASC,cACdC,IAAkD;IAElD,OACE,CAAE,CAAA,cAAcA,IAAG,KAAOA,CAAAA,KAAKC,QAAQ,KAAK,SAASD,KAAKC,QAAQ,KAAK,IAAG;AAE9E;AAEA,MAAMC,eAAe,CAACD,WACpBA,aAAa,OAAON,UAAUD;AAEhC,gFAAgF,GAChF,MAAMS,eAAe,CAACF,WACpBA,aAAa,WAAW,SAAS;AAEnC,SAASG,oBACPC,MAA6B;IAE7B,MAAMJ,WAAWI,OAAOJ,QAAQ;IAChC,MAAMK,WAAWC,OAAOF,OAAOC,QAAQ;IACvC,MAAME,QAAQZ,WAAW,CAACK,SAAS;IAEnC,OAAQJ,UAAUI;QAChB,KAAK;YACH,OAAO,GAAGK,WAAWE,QAAQL,aAAaF,WAAW;QACvD,KAAK;YAAQ;gBACX,MAAM,EAAEQ,MAAM,EAAE,GAAGJ;gBACnB,OAAO,GAAGC,WAAWE,MAAM,CAAC,EAAEC,OAAOC,GAAG,CAACZ,iBAAiBa,IAAI,CAAC,KAAK,CAAC,CAAC;YACxE;QACA,KAAK;YAAS;gBACZ,MAAM,EAAEC,KAAK,EAAEC,GAAG,EAAE,GAAGR;gBACvB,OAAO,GAAGC,WAAWE,MAAM,CAAC,EAAEV,gBAAgBc,OAAO,CAAC,EAAEd,gBAAgBe,KAAK,CAAC,CAAC;YACjF;QACA;YAAS;gBACP,MAAM,EAAEC,KAAK,EAAE,GAAGT;gBAClB,OAAO,GAAGC,WAAWE,QAAQV,gBAAgBgB,QAAQ;YACvD;IACF;AACF;AAEA;;;;CAIC,GACD,SAASC,cACPf,IAAkD,EAClDgB,MAAsB;IAEtB,IAAI,CAACjB,cAAcC,OAAO,OAAOI,oBAAoBJ;IAErD,MAAMiB,QAAQjB,KAAKS,MAAM,CACtBC,GAAG,CAACQ,CAAAA,QAASH,cAAcG,OAAOlB,KAAKC,QAAQ,GAC/CI,MAAM,CAACc,CAAAA,OAAQA,SAAS;IAE3B,IAAIF,MAAMG,MAAM,KAAK,GAAG,OAAO;IAE/B,MAAMC,OAAOJ,MAAMN,IAAI,CAACT,aAAaF,KAAKC,QAAQ;IAClD,MAAMqB,mBACJL,MAAMG,MAAM,GAAG,KAAKJ,WAAWO,aAAaP,WAAWhB,KAAKC,QAAQ;IAEtE,OAAOqB,mBAAmB,CAAC,CAAC,EAAED,KAAK,CAAC,CAAC,GAAGA;AAC1C;AAEA;;;;;;;CAOC,GACD,OAAO,SAASG,cACdC,SAAsC;IAEtC,IAAI,CAACA,aAAaA,UAAUL,MAAM,KAAK,GAAG,OAAO;IAEjD,MAAMH,QAAkB,EAAE;IAC1B,KAAK,MAAMS,SAASD,UAAW;QAC7B,MAAME,QAAQC,MAAMC,OAAO,CAACH,SAASA,QAAQ;YAACA;SAAM;QACpD,KAAK,MAAM1B,QAAQ2B,MAAO;YACxB,MAAMN,OAAON,cAAcf,MAAM;YACjC,IAAIqB,SAAS,IAAIJ,MAAMa,IAAI,CAACT;QAC9B;IACF;IAEA,OAAOJ,MAAMN,IAAI,CAACjB;AACpB"}

package/dist/rsql/sort-param.d.ts

@@ -0,0 +1,20 @@
+import type { Entity, EntityConstructor } from '../types/Entity.js';
+import type { EntitySorting } from '../types/EntitySorting.js';
+/**
+ * Serializes an {@link EntityLoadRequest}'s `sorting` into the `sort`
+ * parameter's value. Absent or empty sorting yields `''`, which callers omit
+ * from the URL rather than sending empty.
+ */
+export declare function serializeSort<TEntity extends Entity>(sorting?: EntitySorting<TEntity>[]): string;
+/**
+ * Parses the `sort` parameter into the request's `sorting`, allowlisting every
+ * member against the entity's `sortable` metadata for the same reason
+ * {@link coerceFiltering} does: an unchecked property name would let a client
+ * sort by a member the entity never meant to expose, and an unindexed one is a
+ * collection scan.
+ *
+ * Returns a single-record array — one record whose numeric keys carry the
+ * precedence — or `undefined` when there is nothing to sort by.
+ */
+export declare function parseSort<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, parameter: string | null | undefined): EntitySorting<TEntity>[] | undefined;
+//# sourceMappingURL=sort-param.d.ts.map

package/dist/rsql/sort-param.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-param.d.ts","sourceRoot":"","sources":["../../src/rsql/sort-param.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,2BAA2B,CAAC;AA6B/E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,EAClD,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,GACjC,MAAM,CAMR;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,SAAS,MAAM,EAC9C,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACnC,aAAa,CAAC,OAAO,CAAC,EAAE,GAAG,SAAS,CAgCtC"}

package/dist/rsql/sort-param.js

@@ -0,0 +1,66 @@
+import { EntifixBuildError } from '../base-entities/entifix-error/index.js';
+import { allowedDescriptors } from './coerce-rsql.js';
+/**
+ * RSQL standardizes filtering only, so sorting travels in its own `sort`
+ * parameter: `+name,-code`. The sign is the direction (`-` descending, `+` or
+ * none ascending) and the list position is the precedence — which is exactly
+ * what `EntitySorting`'s numeric keys mean, so the two forms map one to one.
+ */ const SEPARATOR = ',';
+/** Flattens the sorting records into `[property, direction]` in priority order. */ function orderedEntries(sorting) {
+    const entries = [];
+    for (const record of sorting){
+        for (const priority of Object.keys(record).map(Number).sort((left, right)=>left - right)){
+            const entry = record[priority];
+            if (entry) entries.push([
+                String(entry.property),
+                entry.type
+            ]);
+        }
+    }
+    return entries;
+}
+/**
+ * Serializes an {@link EntityLoadRequest}'s `sorting` into the `sort`
+ * parameter's value. Absent or empty sorting yields `''`, which callers omit
+ * from the URL rather than sending empty.
+ */ export function serializeSort(sorting) {
+    if (!sorting || sorting.length === 0) return '';
+    return orderedEntries(sorting).map(([property, type])=>`${type === 'desc' ? '-' : '+'}${property}`).join(SEPARATOR);
+}
+/**
+ * Parses the `sort` parameter into the request's `sorting`, allowlisting every
+ * member against the entity's `sortable` metadata for the same reason
+ * {@link coerceFiltering} does: an unchecked property name would let a client
+ * sort by a member the entity never meant to expose, and an unindexed one is a
+ * collection scan.
+ *
+ * Returns a single-record array — one record whose numeric keys carry the
+ * precedence — or `undefined` when there is nothing to sort by.
+ */ export function parseSort(entityConstructor, parameter) {
+    const text = parameter == null ? void 0 : parameter.trim();
+    if (!text) return undefined;
+    const allowed = allowedDescriptors(entityConstructor, (descriptor)=>descriptor.sortable);
+    const record = {};
+    let priority = 0;
+    for (const rawTerm of text.split(SEPARATOR)){
+        const term = rawTerm.trim();
+        if (term === '') continue;
+        const type = term.startsWith('-') ? 'desc' : 'asc';
+        const name = term.replace(/^[+-]/, '');
+        const descriptor = allowed.get(name);
+        if (!descriptor) {
+            throw new EntifixBuildError(`"${name}" is not a sortable member`, undefined, {
+                property: name
+            });
+        }
+        record[priority++] = {
+            property: descriptor.key,
+            type
+        };
+    }
+    return priority === 0 ? undefined : [
+        record
+    ];
+}
+
+//# sourceMappingURL=sort-param.js.map