meno-core 1.0.53 → 1.1.0

package/lib/shared/cmsQuery.test.ts

@@ -0,0 +1,81 @@
+import { test, expect, describe } from 'bun:test';
+import { applyCmsFilters, applyCmsSorting, matchCmsCondition, isCmsFilterCondition } from './cmsQuery';
+
+describe('cmsQuery — filters', () => {
+  const items = [
+    { _id: 'a', title: 'Alpha', views: 10, featured: true },
+    { _id: 'b', title: 'Beta', views: 30, featured: false },
+    { _id: 'c', title: 'Gamma', views: 20, featured: true },
+  ];
+
+  test('plain equality map filters on every key', () => {
+    expect(applyCmsFilters(items, { featured: true }).map((i) => i._id)).toEqual(['a', 'c']);
+  });
+
+  test('operators eq/neq/gt/gte/lt/lte/contains/in', () => {
+    expect(applyCmsFilters(items, { field: 'views', operator: 'gt', value: 15 }).map((i) => i._id)).toEqual(['b', 'c']);
+    expect(applyCmsFilters(items, { field: 'views', operator: 'lte', value: 20 }).map((i) => i._id)).toEqual([
+      'a',
+      'c',
+    ]);
+    expect(applyCmsFilters(items, { field: 'title', operator: 'contains', value: 'amm' }).map((i) => i._id)).toEqual([
+      'c',
+    ]);
+    expect(applyCmsFilters(items, { field: '_id', operator: 'in', value: ['a', 'b'] }).map((i) => i._id)).toEqual([
+      'a',
+      'b',
+    ]);
+  });
+
+  test('array of conditions ANDs', () => {
+    const r = applyCmsFilters(items, [
+      { field: 'featured', operator: 'eq', value: true },
+      { field: 'views', operator: 'gte', value: 20 },
+    ]);
+    expect(r.map((i) => i._id)).toEqual(['c']);
+  });
+
+  test('unknown operator never matches; isCmsFilterCondition discriminates', () => {
+    expect(matchCmsCondition(items[0]!, { field: 'x', operator: 'weird' as never, value: 1 })).toBe(false);
+    expect(isCmsFilterCondition({ field: 'x' })).toBe(true);
+    expect(isCmsFilterCondition({ featured: true })).toBe(false);
+  });
+});
+
+describe('cmsQuery — sorting', () => {
+  test('numeric asc/desc, does not mutate input', () => {
+    const items = [{ n: 3 }, { n: 1 }, { n: 2 }];
+    expect(applyCmsSorting(items, { field: 'n', order: 'asc' }).map((i) => i.n)).toEqual([1, 2, 3]);
+    expect(applyCmsSorting(items, { field: 'n', order: 'desc' }).map((i) => i.n)).toEqual([3, 2, 1]);
+    expect(items.map((i) => i.n)).toEqual([3, 1, 2]); // original untouched
+  });
+
+  // Regression for the SSR-remote drift: the copy there had dropped this case, so a
+  // boolean field sorted differently for remote/Sanity items than for local ones.
+  test('boolean fields: desc → true first, asc → false first', () => {
+    const items = [
+      { id: 'x', on: false },
+      { id: 'y', on: true },
+      { id: 'z', on: false },
+    ];
+    expect(applyCmsSorting(items, { field: 'on', order: 'desc' })[0]!.id).toBe('y');
+    expect(applyCmsSorting(items, { field: 'on', order: 'asc' }).at(-1)!.id).toBe('y');
+  });
+
+  test('multi-key sort: primary then tiebreaker', () => {
+    const items = [
+      { cat: 'b', n: 1 },
+      { cat: 'a', n: 2 },
+      { cat: 'a', n: 1 },
+    ];
+    const r = applyCmsSorting(items, [
+      { field: 'cat', order: 'asc' },
+      { field: 'n', order: 'desc' },
+    ]);
+    expect(r).toEqual([
+      { cat: 'a', n: 2 },
+      { cat: 'a', n: 1 },
+      { cat: 'b', n: 1 },
+    ]);
+  });
+});

package/lib/shared/cmsQuery.ts

@@ -0,0 +1,92 @@
+/**
+ * CMS query primitives — the SINGLE source of truth for filtering and sorting
+ * CMS items. Pure (no IO), so it is shared by every consumer that has to apply a
+ * `CMSListQuery`'s `filter`/`sort` to a set of items:
+ *   - `meno-core` CMSService (local file-backed collections)
+ *   - `meno-core` SSR renderer (remote / Sanity-backed list items)
+ *   - `meno-astro` runtime `getCollectionList` (built/SSR Astro pages)
+ *
+ * These used to be three hand-copied implementations; one (the SSR remote path)
+ * had already drifted and dropped the boolean-sort special case, so a boolean
+ * field sorted differently for remote items than for local ones. Keeping the
+ * logic here — operating on plain `Record<string, unknown>` rows so it works for
+ * both `CMSItem` and the astro runtime's item shape — prevents that recurring.
+ */
+
+import type { CMSFilterCondition, CMSSortConfig } from './types/cms';
+
+/** A CMS item, structurally — query primitives only ever index it by field name. */
+type Row = Record<string, unknown>;
+
+/** True when `obj` is a single {@link CMSFilterCondition} (vs a plain equality map). */
+export function isCmsFilterCondition(obj: unknown): obj is CMSFilterCondition {
+  return typeof obj === 'object' && obj !== null && 'field' in obj;
+}
+
+/** Evaluate one filter condition against an item. Unknown operators never match. */
+export function matchCmsCondition(item: Row, condition: CMSFilterCondition): boolean {
+  const value = item[condition.field];
+  switch (condition.operator || 'eq') {
+    case 'eq':
+      return value === condition.value;
+    case 'neq':
+      return value !== condition.value;
+    case 'gt':
+      return (value as number) > (condition.value as number);
+    case 'gte':
+      return (value as number) >= (condition.value as number);
+    case 'lt':
+      return (value as number) < (condition.value as number);
+    case 'lte':
+      return (value as number) <= (condition.value as number);
+    case 'contains':
+      return String(value).includes(String(condition.value));
+    case 'in':
+      return Array.isArray(condition.value) && condition.value.includes(value);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Filter items by a `CMSListQuery.filter`: a plain equality map (`{ featured: true }`
+ * → every key must match), a single condition, or an array of conditions (AND).
+ */
+export function applyCmsFilters<T extends Row>(
+  items: T[],
+  filter: CMSFilterCondition | CMSFilterCondition[] | Record<string, unknown>,
+): T[] {
+  if (!Array.isArray(filter) && !isCmsFilterCondition(filter)) {
+    const entries = Object.entries(filter);
+    return items.filter((item) => entries.every(([key, value]) => item[key] === value));
+  }
+  const conditions = Array.isArray(filter) ? filter : [filter as CMSFilterCondition];
+  return items.filter((item) => conditions.every((cond) => matchCmsCondition(item, cond)));
+}
+
+/**
+ * Stable multi-key sort. Booleans compare specially (desc → true first); other
+ * values compare as primitives. Returns a new array (input is not mutated).
+ */
+export function applyCmsSorting<T extends Row>(items: T[], sort: CMSSortConfig | CMSSortConfig[]): T[] {
+  const sorts = Array.isArray(sort) ? sort : [sort];
+  return [...items].sort((a, b) => {
+    for (const s of sorts) {
+      const aVal = a[s.field];
+      const bVal = b[s.field];
+      const isDesc = s.order === 'desc';
+
+      // Boolean fields: desc puts `true` first, asc puts `false` first.
+      if (typeof aVal === 'boolean' && typeof bVal === 'boolean') {
+        if (aVal === bVal) continue;
+        return isDesc ? (aVal ? -1 : 1) : aVal ? 1 : -1;
+      }
+
+      let result = 0;
+      if ((aVal as string | number) < (bVal as string | number)) result = -1;
+      else if ((aVal as string | number) > (bVal as string | number)) result = 1;
+      if (result !== 0) return isDesc ? -result : result;
+    }
+    return 0;
+  });
+}

package/lib/shared/cmsQueryParser.test.ts

@@ -7,7 +7,7 @@ import {
   parseSortExpression,
   serializeSortExpression,
   parseFilterExpression,
-  serializeFilterExpression
+  serializeFilterExpression,
 } from './cmsQueryParser';
 
 describe('parseSortExpression', () => {
@@ -29,11 +29,11 @@ describe('parseSortExpression', () => {
   test('parses multiple fields', () => {
     expect(parseSortExpression('date desc, title')).toEqual([
       { field: 'date', order: 'desc' },
-      { field: 'title', order: 'asc' }
+      { field: 'title', order: 'asc' },
     ]);
     expect(parseSortExpression('date desc, title asc')).toEqual([
       { field: 'date', order: 'desc' },
-      { field: 'title', order: 'asc' }
+      { field: 'title', order: 'asc' },
     ]);
   });
 
@@ -41,7 +41,7 @@ describe('parseSortExpression', () => {
     expect(parseSortExpression('  date   desc  ')).toEqual({ field: 'date', order: 'desc' });
     expect(parseSortExpression('date desc,   title asc')).toEqual([
       { field: 'date', order: 'desc' },
-      { field: 'title', order: 'asc' }
+      { field: 'title', order: 'asc' },
     ]);
   });
 });
@@ -60,10 +60,12 @@ describe('serializeSortExpression', () => {
   });
 
   test('serializes multiple fields', () => {
-    expect(serializeSortExpression([
-      { field: 'date', order: 'desc' },
-      { field: 'title', order: 'asc' }
-    ])).toBe('date desc, title');
+    expect(
+      serializeSortExpression([
+        { field: 'date', order: 'desc' },
+        { field: 'title', order: 'asc' },
+      ]),
+    ).toBe('date desc, title');
   });
 });
 
@@ -98,32 +100,32 @@ describe('parseFilterExpression', () => {
     expect(parseFilterExpression('price > 100')).toEqual({
       field: 'price',
       operator: 'gt',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('price >= 100')).toEqual({
       field: 'price',
       operator: 'gte',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('price < 100')).toEqual({
       field: 'price',
       operator: 'lt',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('price <= 100')).toEqual({
       field: 'price',
       operator: 'lte',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('status != draft')).toEqual({
       field: 'status',
       operator: 'neq',
-      value: 'draft'
+      value: 'draft',
     });
     expect(parseFilterExpression('status <> draft')).toEqual({
       field: 'status',
       operator: 'neq',
-      value: 'draft'
+      value: 'draft',
     });
   });
 
@@ -131,12 +133,12 @@ describe('parseFilterExpression', () => {
     expect(parseFilterExpression('title contains hello')).toEqual({
       field: 'title',
       operator: 'contains',
-      value: 'hello'
+      value: 'hello',
     });
     expect(parseFilterExpression('title ~ hello')).toEqual({
       field: 'title',
       operator: 'contains',
-      value: 'hello'
+      value: 'hello',
     });
   });
 
@@ -144,35 +146,35 @@ describe('parseFilterExpression', () => {
     expect(parseFilterExpression('category in news, blog')).toEqual({
       field: 'category',
       operator: 'in',
-      value: ['news', 'blog']
+      value: ['news', 'blog'],
     });
     expect(parseFilterExpression('status in draft, published, archived')).toEqual({
       field: 'status',
       operator: 'in',
-      value: ['draft', 'published', 'archived']
+      value: ['draft', 'published', 'archived'],
     });
   });
 
   test('parses template values', () => {
     expect(parseFilterExpression('category = {{cms.category}}')).toEqual({
-      category: '{{cms.category}}'
+      category: '{{cms.category}}',
     });
     expect(parseFilterExpression('author = {{cms.authorId}}')).toEqual({
-      author: '{{cms.authorId}}'
+      author: '{{cms.authorId}}',
     });
   });
 
   test('parses multiple conditions (newline)', () => {
     expect(parseFilterExpression('featured = true\nprice > 100')).toEqual([
       { field: 'featured', value: true },
-      { field: 'price', operator: 'gt', value: 100 }
+      { field: 'price', operator: 'gt', value: 100 },
     ]);
   });
 
   test('parses multiple conditions (semicolon)', () => {
     expect(parseFilterExpression('featured = true; price > 100')).toEqual([
       { field: 'featured', value: true },
-      { field: 'price', operator: 'gt', value: 100 }
+      { field: 'price', operator: 'gt', value: 100 },
     ]);
   });
 
@@ -198,20 +200,20 @@ describe('parseFilterExpression', () => {
     expect(parseFilterExpression('price gt 100')).toEqual({
       field: 'price',
       operator: 'gt',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('price gte 100')).toEqual({
       field: 'price',
       operator: 'gte',
-      value: 100
+      value: 100,
     });
     expect(parseFilterExpression('status eq active')).toEqual({
-      status: 'active'
+      status: 'active',
     });
     expect(parseFilterExpression('status neq draft')).toEqual({
       field: 'status',
       operator: 'neq',
-      value: 'draft'
+      value: 'draft',
     });
   });
 });
@@ -227,32 +229,38 @@ describe('serializeFilterExpression', () => {
   });
 
   test('serializes condition with operator', () => {
-    expect(serializeFilterExpression({
-      field: 'price',
-      operator: 'gt',
-      value: 100
-    })).toBe('price > 100');
-    expect(serializeFilterExpression({
-      field: 'status',
-      operator: 'neq',
-      value: 'draft'
-    })).toBe('status != draft');
+    expect(
+      serializeFilterExpression({
+        field: 'price',
+        operator: 'gt',
+        value: 100,
+      }),
+    ).toBe('price > 100');
+    expect(
+      serializeFilterExpression({
+        field: 'status',
+        operator: 'neq',
+        value: 'draft',
+      }),
+    ).toBe('status != draft');
   });
 
   test('serializes multiple conditions', () => {
     const result = serializeFilterExpression([
       { field: 'featured', value: true },
-      { field: 'price', operator: 'gt', value: 100 }
+      { field: 'price', operator: 'gt', value: 100 },
     ]);
     expect(result).toBe('featured = true\nprice > 100');
   });
 
   test('serializes in operator', () => {
-    expect(serializeFilterExpression({
-      field: 'category',
-      operator: 'in',
-      value: ['news', 'blog']
-    })).toBe('category in news, blog');
+    expect(
+      serializeFilterExpression({
+        field: 'category',
+        operator: 'in',
+        value: ['news', 'blog'],
+      }),
+    ).toBe('category in news, blog');
   });
 
   test('serializes template values', () => {

package/lib/shared/cmsQueryParser.ts

@@ -22,15 +22,18 @@ import type { CMSFilterCondition, CMSSortConfig, CMSFilterOperator } from './typ
 export function parseSortExpression(expr: string): CMSSortConfig | CMSSortConfig[] | undefined {
   if (!expr.trim()) return undefined;
 
-  const parts = expr.split(',').map(p => p.trim()).filter(Boolean);
-  const sorts: CMSSortConfig[] = parts.map(part => {
+  const parts = expr
+    .split(',')
+    .map((p) => p.trim())
+    .filter(Boolean);
+  const sorts: CMSSortConfig[] = parts.map((part) => {
     const tokens = part.split(/\s+/);
-    const field = tokens[0];
+    const field = tokens[0] ?? '';
     const order = tokens[1]?.toLowerCase() === 'desc' ? 'desc' : 'asc';
     return { field, order };
   });
 
-  return sorts.length === 1 ? sorts[0] : sorts;
+  return sorts.length === 1 ? (sorts[0] as CMSSortConfig) : sorts;
 }
 
 /**
@@ -39,19 +42,22 @@ export function parseSortExpression(expr: string): CMSSortConfig | CMSSortConfig
 export function serializeSortExpression(sort: CMSSortConfig | CMSSortConfig[] | undefined): string {
   if (!sort) return '';
   const sorts = Array.isArray(sort) ? sort : [sort];
-  return sorts.map(s => `${s.field}${s.order === 'desc' ? ' desc' : ''}`).join(', ');
+  return sorts.map((s) => `${s.field}${s.order === 'desc' ? ' desc' : ''}`).join(', ');
 }
 
 /**
  * Parse filter expression: "featured = true; price > 100"
  */
 export function parseFilterExpression(
-  expr: string
+  expr: string,
 ): CMSFilterCondition | CMSFilterCondition[] | Record<string, unknown> | undefined {
   if (!expr.trim()) return undefined;
 
   // Split by newline or semicolon
-  const lines = expr.split(/[;\n]/).map(l => l.trim()).filter(Boolean);
+  const lines = expr
+    .split(/[;\n]/)
+    .map((l) => l.trim())
+    .filter(Boolean);
   const conditions: CMSFilterCondition[] = [];
 
   for (const line of lines) {
@@ -62,11 +68,12 @@ export function parseFilterExpression(
   if (conditions.length === 0) return undefined;
 
   // Single simple equality can use shorthand: { field: value }
-  if (conditions.length === 1 && (!conditions[0].operator || conditions[0].operator === 'eq')) {
-    return { [conditions[0].field]: conditions[0].value };
+  const first = conditions[0];
+  if (conditions.length === 1 && first && (!first.operator || first.operator === 'eq')) {
+    return { [first.field]: first.value };
   }
 
-  return conditions.length === 1 ? conditions[0] : conditions;
+  return conditions.length === 1 && first ? first : conditions;
 }
 
 function parseFilterLine(line: string): CMSFilterCondition | null {
@@ -75,7 +82,10 @@ function parseFilterLine(line: string): CMSFilterCondition | null {
   const match = line.match(/^(\w+)\s*(==|!=|<>|>=|<=|=|>|<|contains|~|in|gte|lte|neq|gt|lt|eq)\s*(.+)$/i);
   if (!match) return null;
 
-  const [, field, op, rawValue] = match;
+  // The regex matched (guarded above), so groups 1–3 are present; default for the type system.
+  const field = match[1] ?? '';
+  const op = match[2] ?? '';
+  const rawValue = match[3] ?? '';
   const operator = normalizeOperator(op);
   const value = parseValue(rawValue.trim(), operator);
 
@@ -90,14 +100,23 @@ function parseFilterLine(line: string): CMSFilterCondition | null {
 function normalizeOperator(op: string): CMSFilterOperator {
   const normalized = op.toLowerCase();
   const map: Record<string, CMSFilterOperator> = {
-    '=': 'eq', '==': 'eq', 'eq': 'eq',
-    '!=': 'neq', '<>': 'neq', 'neq': 'neq',
-    '>': 'gt', 'gt': 'gt',
-    '>=': 'gte', 'gte': 'gte',
-    '<': 'lt', 'lt': 'lt',
-    '<=': 'lte', 'lte': 'lte',
-    'contains': 'contains', '~': 'contains',
-    'in': 'in'
+    '=': 'eq',
+    '==': 'eq',
+    eq: 'eq',
+    '!=': 'neq',
+    '<>': 'neq',
+    neq: 'neq',
+    '>': 'gt',
+    gt: 'gt',
+    '>=': 'gte',
+    gte: 'gte',
+    '<': 'lt',
+    lt: 'lt',
+    '<=': 'lte',
+    lte: 'lte',
+    contains: 'contains',
+    '~': 'contains',
+    in: 'in',
   };
   return map[normalized] || 'eq';
 }
@@ -110,7 +129,7 @@ function parseValue(raw: string, operator: CMSFilterOperator): unknown {
 
   // Handle 'in' operator - comma separated list
   if (operator === 'in') {
-    return raw.split(',').map(v => parseScalarValue(v.trim()));
+    return raw.split(',').map((v) => parseScalarValue(v.trim()));
   }
 
   return parseScalarValue(raw);
@@ -123,7 +142,7 @@ function parseScalarValue(raw: string): unknown {
 
   // Number
   const num = Number(raw);
-  if (!isNaN(num) && raw !== '') return num;
+  if (!Number.isNaN(num) && raw !== '') return num;
 
   // String (strip quotes if present)
   if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
@@ -137,7 +156,7 @@ function parseScalarValue(raw: string): unknown {
  * Serialize filter config back to expression
  */
 export function serializeFilterExpression(
-  filter: CMSFilterCondition | CMSFilterCondition[] | Record<string, unknown> | undefined
+  filter: CMSFilterCondition | CMSFilterCondition[] | Record<string, unknown> | undefined,
 ): string {
   if (!filter) return '';
 
@@ -150,26 +169,29 @@ export function serializeFilterExpression(
 
   // Array or single condition
   const conditions = Array.isArray(filter) ? filter : [filter as CMSFilterCondition];
-  return conditions.map(c => {
-    const op = c.operator || 'eq';
-    const opStr = operatorToString(op);
-    const valStr = op === 'in' && Array.isArray(c.value)
-      ? c.value.map(v => serializeValue(v)).join(', ')
-      : serializeValue(c.value);
-    return `${c.field} ${opStr} ${valStr}`;
-  }).join('\n');
+  return conditions
+    .map((c) => {
+      const op = c.operator || 'eq';
+      const opStr = operatorToString(op);
+      const valStr =
+        op === 'in' && Array.isArray(c.value)
+          ? c.value.map((v) => serializeValue(v)).join(', ')
+          : serializeValue(c.value);
+      return `${c.field} ${opStr} ${valStr}`;
+    })
+    .join('\n');
 }
 
 function operatorToString(op: CMSFilterOperator): string {
   const map: Record<CMSFilterOperator, string> = {
-    'eq': '=',
-    'neq': '!=',
-    'gt': '>',
-    'gte': '>=',
-    'lt': '<',
-    'lte': '<=',
-    'contains': 'contains',
-    'in': 'in'
+    eq: '=',
+    neq: '!=',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    contains: 'contains',
+    in: 'in',
   };
   return map[op] || '=';
 }

package/lib/shared/colorConversions.ts

@@ -39,9 +39,9 @@ export function parseCssRgb(value: string): RgbColor | null {
   const m = value.trim().match(RGB_RE);
   if (!m) return null;
   return {
-    r: clamp(parseInt(m[1], 10), 0, 255),
-    g: clamp(parseInt(m[2], 10), 0, 255),
-    b: clamp(parseInt(m[3], 10), 0, 255),
+    r: clamp(parseInt(m[1] ?? '', 10), 0, 255),
+    g: clamp(parseInt(m[2] ?? '', 10), 0, 255),
+    b: clamp(parseInt(m[3] ?? '', 10), 0, 255),
   };
 }
 
@@ -50,9 +50,9 @@ export function parseCssHsl(value: string): HslColor | null {
   const m = value.trim().match(HSL_RE);
   if (!m) return null;
   return {
-    h: clamp(parseFloat(m[1]), 0, 360),
-    s: clamp(parseFloat(m[2]), 0, 100),
-    l: clamp(parseFloat(m[3]), 0, 100),
+    h: clamp(parseFloat(m[1] ?? ''), 0, 360),
+    s: clamp(parseFloat(m[2] ?? ''), 0, 100),
+    l: clamp(parseFloat(m[3] ?? ''), 0, 100),
   };
 }
 
@@ -74,9 +74,9 @@ export function hslToCssString(hsl: HslColor): string {
 function expandHex(hex: string): string {
   const h = hex.replace('#', '');
   if (h.length === 3) {
-    return '#' + h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    return `#${h[0]}${h[0]}${h[1]}${h[1]}${h[2]}${h[2]}`;
   }
-  return '#' + h;
+  return `#${h}`;
 }
 
 /** Convert a hex color string to an RgbColor */
@@ -94,7 +94,7 @@ export function rgbToHex(rgb: RgbColor): string {
   const r = clamp(Math.round(rgb.r), 0, 255);
   const g = clamp(Math.round(rgb.g), 0, 255);
   const b = clamp(Math.round(rgb.b), 0, 255);
-  return '#' + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+  return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
 }
 
 // ── RGB ↔ HSL ──────────────────────────────────────────────