@plumile/filter-query 0.1.17

package/lib/types/types.d.ts

@@ -0,0 +1,43 @@
+import type { Diagnostic } from './errors.js';
+export type ScalarOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'contains' | 'sw' | 'ew';
+export type BetweenOperator = 'between';
+export type ListOperator = 'in' | 'nin';
+export type Operator = ScalarOperator | BetweenOperator | ListOperator;
+export type PrimitiveKind = 'number' | 'string';
+export interface FieldDescriptorBase<TKind extends PrimitiveKind> {
+    readonly kind: TKind;
+    readonly operators: readonly Operator[];
+    readonly parse?: (raw: string) => unknown;
+    readonly serialize?: (value: unknown) => string;
+}
+export type NumberFieldDescriptor = FieldDescriptorBase<'number'> & {
+    readonly parse?: (raw: string) => number | undefined;
+    readonly serialize?: (value: number) => string;
+};
+export type StringFieldDescriptor = FieldDescriptorBase<'string'> & {
+    readonly parse?: (raw: string) => string | undefined;
+    readonly serialize?: (value: string) => string;
+};
+export type FieldDescriptor = NumberFieldDescriptor | StringFieldDescriptor;
+export type Schema = Readonly<Record<string, FieldDescriptor>>;
+type OperatorKeys<D extends FieldDescriptor> = Extract<D['operators'][number], ScalarOperator>;
+type ScalarMap<D extends FieldDescriptor> = D extends FieldDescriptorBase<'number'> ? Record<OperatorKeys<D>, number | undefined> : Record<OperatorKeys<D>, string | undefined>;
+type BetweenMap<D extends FieldDescriptor> = 'between' extends D['operators'][number] ? {
+    between?: D extends FieldDescriptorBase<'number'> ? readonly [number, number] : readonly [string, string];
+} : Record<never, never>;
+type ListOps<D extends FieldDescriptor> = Extract<D['operators'][number], ListOperator>;
+type ListMap<D extends FieldDescriptor> = ('in' extends ListOps<D> ? {
+    in?: D extends FieldDescriptorBase<'number'> ? readonly number[] : readonly string[];
+} : Record<never, never>) & ('nin' extends ListOps<D> ? {
+    nin?: D extends FieldDescriptorBase<'number'> ? readonly number[] : readonly string[];
+} : Record<never, never>);
+export type InferField<D extends FieldDescriptor> = Partial<ScalarMap<D> & BetweenMap<D> & ListMap<D>>;
+export type InferFilters<S extends Schema> = {
+    [K in keyof S]?: InferField<S[K]>;
+};
+export interface ParseResult<S extends Schema> {
+    readonly filters: InferFilters<S>;
+    readonly diagnostics: Diagnostic[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.d.ts.map

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

package/lib/types.d.ts

@@ -0,0 +1,43 @@
+import type { Diagnostic } from './errors.js';
+export type ScalarOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'contains' | 'sw' | 'ew';
+export type BetweenOperator = 'between';
+export type ListOperator = 'in' | 'nin';
+export type Operator = ScalarOperator | BetweenOperator | ListOperator;
+export type PrimitiveKind = 'number' | 'string';
+export interface FieldDescriptorBase<TKind extends PrimitiveKind> {
+    readonly kind: TKind;
+    readonly operators: readonly Operator[];
+    readonly parse?: (raw: string) => unknown;
+    readonly serialize?: (value: unknown) => string;
+}
+export type NumberFieldDescriptor = FieldDescriptorBase<'number'> & {
+    readonly parse?: (raw: string) => number | undefined;
+    readonly serialize?: (value: number) => string;
+};
+export type StringFieldDescriptor = FieldDescriptorBase<'string'> & {
+    readonly parse?: (raw: string) => string | undefined;
+    readonly serialize?: (value: string) => string;
+};
+export type FieldDescriptor = NumberFieldDescriptor | StringFieldDescriptor;
+export type Schema = Readonly<Record<string, FieldDescriptor>>;
+type OperatorKeys<D extends FieldDescriptor> = Extract<D['operators'][number], ScalarOperator>;
+type ScalarMap<D extends FieldDescriptor> = D extends FieldDescriptorBase<'number'> ? Record<OperatorKeys<D>, number | undefined> : Record<OperatorKeys<D>, string | undefined>;
+type BetweenMap<D extends FieldDescriptor> = 'between' extends D['operators'][number] ? {
+    between?: D extends FieldDescriptorBase<'number'> ? readonly [number, number] : readonly [string, string];
+} : Record<never, never>;
+type ListOps<D extends FieldDescriptor> = Extract<D['operators'][number], ListOperator>;
+type ListMap<D extends FieldDescriptor> = ('in' extends ListOps<D> ? {
+    in?: D extends FieldDescriptorBase<'number'> ? readonly number[] : readonly string[];
+} : Record<never, never>) & ('nin' extends ListOps<D> ? {
+    nin?: D extends FieldDescriptorBase<'number'> ? readonly number[] : readonly string[];
+} : Record<never, never>);
+export type InferField<D extends FieldDescriptor> = Partial<ScalarMap<D> & BetweenMap<D> & ListMap<D>>;
+export type InferFilters<S extends Schema> = {
+    [K in keyof S]?: InferField<S[K]>;
+};
+export interface ParseResult<S extends Schema> {
+    readonly filters: InferFilters<S>;
+    readonly diagnostics: Diagnostic[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

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

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@plumile/filter-query",
+  "version": "0.1.17",
+  "description": "Typed filter query string parser and serializer for Plumile ecosystem",
+  "type": "module",
+  "main": "lib/esm/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "typings": "lib/types/index.d.ts",
+  "exports": "./lib/esm/index.js",
+  "sideEffects": false,
+  "author": "Olivier Hardy <olivier@plumile.com>",
+  "scripts": {
+    "build:package": "./tools/build-package.sh",
+    "build:package:esm": "tsc --build tsconfig.esm.json",
+    "build:package:types": "tsc --build tsconfig.types.json",
+    "check:build-package": "tsc --noEmit",
+    "clean": "rimraf lib && rimraf *.tsbuildinfo",
+    "test:build-package": "./tools/test-build-package.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/plumile/js"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/plumile/js/-/issues"
+  },
+  "engines": {
+    "node": ">=21.0.0",
+    "npm": ">=8.0.0"
+  },
+  "devDependencies": {
+    "rimraf": "6.0.1",
+    "typescript": "5.9.2"
+  },
+  "peerDependencies": {
+    "tslib": ">=2.8.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "9b42a2afd74c8161c475436751ae90d0240c22a1"
+}

package/src/__tests__/additional-coverage.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { parse } from '../parse.js';
+import { removeFilter, mergeFilters } from '../mutate.js';
+import { stringify } from '../stringify.js';
+
+describe('additional coverage', () => {
+  const baseSchema = defineSchema({
+    price: numberField(['gt', 'lte', 'between', 'in']),
+    title: stringField(['contains', 'eq']),
+  });
+
+  it('removeFilter(operator) prunes field entirely when last operator removed', () => {
+    const onlyGt = parse('price.gt=5', baseSchema).filters;
+    const removed = removeFilter(onlyGt, 'price', 'gt');
+    expect(removed.price).toBeUndefined();
+  });
+
+  it('removeFilter on missing field returns same reference', () => {
+    const empty = parse('', baseSchema).filters;
+    const result = removeFilter(empty, 'price');
+    expect(result).toBe(empty);
+  });
+
+  it('mergeFilters ignores undefined in patch (no change)', () => {
+    const a = parse('price.gt=10', baseSchema).filters;
+    const patch = { price: undefined } as any; // should be ignored
+    const merged = mergeFilters(a, patch);
+    expect(merged).toBe(a);
+  });
+
+  it('stringify respects operator order declared in descriptor (custom order)', () => {
+    const custom = defineSchema({
+      price: numberField(['lte', 'gt', 'in']), // intentionally non-sorted
+    });
+    const { filters } = parse('price.gt=5&price.lte=10&price.in=1,2', custom);
+    const out = stringify(filters, custom);
+    // Expect order: lte then gt then in
+    expect(out.indexOf('price.lte=10')).toBeLessThan(out.indexOf('price.gt=5'));
+    expect(out.indexOf('price.gt=5')).toBeLessThan(out.indexOf('price.in=1,2'));
+  });
+
+  it('parse keeps valid operator despite unknown operator earlier for same field', () => {
+    const { filters, diagnostics } = parse(
+      'price.xyz=9&price.gt=3',
+      baseSchema,
+    );
+    expect(filters.price?.gt).toBe(3);
+    expect(
+      diagnostics.some((d) => {
+        return d.kind === 'UnknownOperator' && d.operator === 'xyz';
+      }),
+    ).toBe(true);
+  });
+
+  it('between with invalid numeric value produces InvalidValue diagnostic', () => {
+    const { filters, diagnostics } = parse('price.between=1,abc', baseSchema);
+    expect(filters.price?.between).toBeUndefined();
+    expect(
+      diagnostics.some((d) => {
+        return d.kind === 'InvalidValue' && d.operator === 'between';
+      }),
+    ).toBe(true);
+  });
+
+  it('leading question mark in search string is handled', () => {
+    const { filters } = parse('?price.gt=42&title.contains=foo', baseSchema);
+    expect(filters.price?.gt).toBe(42);
+    expect(filters.title?.contains).toBe('foo');
+  });
+
+  it('ignores segments without equal sign', () => {
+    const { filters, diagnostics } = parse(
+      'price.gt=5&bogus&title.eq=abc',
+      baseSchema,
+    );
+    expect(filters.price?.gt).toBe(5);
+    expect(filters.title?.eq).toBe('abc');
+    // no diagnostics mandated for segments without '='; implementation ignores them silently
+    expect(diagnostics.length).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/__tests__/list-edge.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField } from '../schema.js';
+import { parse } from '../parse.js';
+
+const schema = defineSchema({ price: numberField(['in']) });
+
+describe('list operator edge cases', () => {
+  it('empty list value produces no filter entry and an InvalidValue diagnostic', () => {
+    const { filters, diagnostics } = parse('price.in=', schema);
+    expect(filters.price).toBeUndefined();
+    const invalids = diagnostics.filter((d) => {
+      return d.kind === 'InvalidValue';
+    });
+    expect(invalids.length).toBe(1);
+  });
+
+  it('decode error in list value yields DecodeError diagnostic and no filter change', () => {
+    const { filters, diagnostics } = parse('price.in=1%ZZ', schema);
+    expect(filters).toEqual({});
+    expect(
+      diagnostics.some((d) => {
+        return d.kind === 'DecodeError' && d.operator === 'in';
+      }),
+    ).toBe(true);
+  });
+});

package/src/__tests__/mutate.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { setFilter, mergeFilters } from '../mutate.js';
+import { parse } from '../parse.js';
+
+const schema = defineSchema({
+  price: numberField(),
+  title: stringField(),
+});
+
+describe('mutations', () => {
+  it('setFilter adds and removes properly', () => {
+    const base = parse('price.gt=10', schema).filters;
+    const withBetween = setFilter(base, schema, 'price', 'between', [1, 2]);
+    expect(withBetween).not.toBe(base);
+    expect(withBetween.price?.between).toEqual([1, 2]);
+    const removed = setFilter(
+      withBetween,
+      schema,
+      'price',
+      'between',
+      undefined,
+    );
+    expect(removed.price?.between).toBeUndefined();
+  });
+
+  it('mergeFilters preserves reference when identical', () => {
+    const a = parse('price.gt=10&title.contains=foo', schema).filters;
+    const b = parse('price.gt=10', schema).filters;
+    const merged = mergeFilters(a, b);
+    expect(merged).toBe(a); // no change because b brings nothing new
+  });
+});

package/src/__tests__/parse-stringify.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { parse } from '../parse.js';
+import { stringify } from '../stringify.js';
+
+const schema = defineSchema({
+  price: numberField(),
+  title: stringField(),
+});
+
+describe('parse & stringify', () => {
+  it('parses scalar and list operators and round-trips', () => {
+    const q =
+      'price.gt=10&price.lte=100&price.in=10,20&title.contains=foo%20bar&title.in=a&title.in=b';
+    const { filters, diagnostics } = parse(q, schema);
+    expect(diagnostics.length).toBe(0);
+    expect(filters.price?.gt).toBe(10);
+    expect(filters.price?.lte).toBe(100);
+    expect(filters.price?.in).toEqual([10, 20]);
+    expect(filters.title?.contains).toBe('foo bar');
+    expect(filters.title?.in).toEqual(['a', 'b']);
+    const out = stringify(filters, schema);
+    // canonical order: price first (decl), then title
+    expect(out).toContain('price.gt=10');
+    expect(out).toContain('price.lte=100');
+    expect(out).toContain('price.in=10,20');
+    expect(out).toContain('title.contains=foo%20bar');
+    expect(out).toContain('title.in=a,b');
+  });
+
+  it('handles between and duplicate between diagnostic', () => {
+    const q = 'price.between=1,5&price.between=2,6';
+    const { filters, diagnostics } = parse(q, schema);
+    expect(filters.price?.between).toEqual([1, 5]);
+    expect(
+      diagnostics.some((d) => {
+        return d.kind === 'DuplicateBetween';
+      }),
+    ).toBe(true);
+  });
+
+  it('round-trips canonical ordering', () => {
+    const q = 'title.ew=bar&price.in=2,1&price.gt=3&title.sw=foo';
+    const { filters } = parse(q, schema);
+    const out = stringify(filters, schema);
+    // price declared before title so should start with price.
+    expect(out.startsWith('price.')).toBe(true);
+    // parsing the output again should yield equivalent filters
+    const again = parse(out, schema).filters;
+    expect(again).toEqual(filters);
+  });
+
+  it('produces diagnostics for invalid number and invalid between arity', () => {
+    const q = 'price.gt=xx&price.between=1,2,3&title.contains=x%ZZ';
+    const { diagnostics } = parse(q, schema);
+    expect(
+      diagnostics.find((d) => {
+        return d.kind === 'InvalidValue';
+      }),
+    ).toBeTruthy();
+    expect(
+      diagnostics.find((d) => {
+        return d.kind === 'InvalidArity';
+      }),
+    ).toBeTruthy();
+    expect(
+      diagnostics.find((d) => {
+        return d.kind === 'DecodeError';
+      }),
+    ).toBeTruthy();
+  });
+
+  it('merges multiple nin occurrences preserving order', () => {
+    const q = 'price.nin=1,2&price.nin=3&price.nin=4,5';
+    const { filters } = parse(q, schema);
+    expect(filters.price?.nin).toEqual([1, 2, 3, 4, 5]);
+    const s = stringify(filters, schema);
+    expect(s).toContain('price.nin=1,2,3,4,5');
+  });
+
+  it('supports eq / neq operators and overrides last-write', () => {
+    const q = 'price.eq=10&price.eq=11&title.eq=foo&title.neq=bar';
+    const { filters } = parse(q, schema);
+    expect(filters.price?.eq).toBe(11); // last write wins
+    expect(filters.title?.eq).toBe('foo');
+    expect(filters.title?.neq).toBe('bar');
+    const s = stringify(filters, schema);
+    expect(s).toContain('price.eq=11');
+    expect(s).toMatch(/title\.eq=foo/);
+    expect(s).toMatch(/title\.neq=bar/);
+  });
+
+  it('supports sw / ew / contains textual operators', () => {
+    const q = 'title.sw=Hello&title.ew=World&title.contains=lo%20Wo';
+    const { filters } = parse(q, schema);
+    expect(filters.title?.sw).toBe('Hello');
+    expect(filters.title?.ew).toBe('World');
+    expect(filters.title?.contains).toBe('lo Wo');
+    const s = stringify(filters, schema);
+    expect(s).toContain('title.sw=Hello');
+    expect(s).toContain('title.ew=World');
+    expect(s).toContain('title.contains=lo%20Wo');
+  });
+});

package/src/__tests__/remove-filter.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { parse } from '../parse.js';
+import { setFilter, removeFilter, isEmpty, mergeFilters } from '../mutate.js';
+
+const schema = defineSchema({
+  price: numberField(['gt', 'lte', 'in']),
+  title: stringField(['contains', 'in']),
+});
+
+describe('removeFilter & isEmpty', () => {
+  it('removeFilter(operator) removes only that operator keeping field if others remain', () => {
+    const base = parse('price.gt=10&price.lte=20', schema).filters;
+    const removed = removeFilter(base, 'price', 'gt');
+    expect(removed.price?.gt).toBeUndefined();
+    expect(removed.price?.lte).toBe(20);
+    // field object replaced (immutability) but root cloned
+    expect(removed).not.toBe(base);
+  });
+
+  it('removeFilter(field) removes entire field object when no operator specified', () => {
+    const base = parse('price.gt=10&title.contains=foo', schema).filters;
+    const withoutPrice = removeFilter(base, 'price');
+    expect(withoutPrice.price).toBeUndefined();
+    expect(withoutPrice.title?.contains).toBe('foo');
+  });
+
+  it('setFilter(undefined) removes operator and prunes empty field', () => {
+    let parsed = parse('price.gt=10', schema).filters;
+    parsed = setFilter(parsed, schema, 'price', 'gt', undefined);
+    expect(parsed.price).toBeUndefined();
+    expect(isEmpty(parsed)).toBe(true);
+  });
+
+  it('mergeFilters applies changes and preserves identity when patch is noop after removals', () => {
+    const a = parse('price.gt=10&price.lte=20', schema).filters;
+    const b = removeFilter(a, 'price', 'lte');
+    // patching with remaining price field should keep reference
+    const merged = mergeFilters(b, { price: b.price } as any);
+    expect(merged).toBe(b);
+    // adding new info changes reference
+    const merged2 = mergeFilters(b, { title: { contains: 'x' } } as any);
+    expect(merged2).not.toBe(b);
+    expect(merged2.title?.contains).toBe('x');
+  });
+});

package/src/__tests__/schema-edge.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { parse } from '../parse.js';
+
+describe('schema & parse edge cases', () => {
+  it('defineSchema returns a frozen object', () => {
+    const schema = defineSchema({ price: numberField(['gt']) });
+    expect(Object.isFrozen(schema)).toBe(true);
+  });
+
+  it('restricted operator whitelist rejects others (UnknownOperator)', () => {
+    const schema = defineSchema({ price: numberField(['gt']) });
+    const { filters, diagnostics } = parse('price.gt=5&price.lte=10', schema);
+    expect(filters.price?.gt).toBe(5);
+    expect(
+      diagnostics.some((d) => {
+        return d.kind === 'UnknownOperator' && d.operator === 'lte';
+      }),
+    ).toBe(true);
+  });
+
+  it('invalid key shapes are ignored silently', () => {
+    const schema = defineSchema({ price: numberField(['gt']) });
+    const { filters, diagnostics } = parse('pricegt=5&price.=6&.gt=7', schema);
+    expect(filters).toEqual({});
+    expect(diagnostics.length).toBe(0);
+  });
+
+  it('list operator keeps only valid numeric items and reports diagnostics for invalid + empty ones', () => {
+    const schema = defineSchema({ price: numberField(['in']) });
+    const { filters, diagnostics } = parse('price.in=1,abc,2,', schema);
+    expect(filters.price?.in).toEqual([1, 2]);
+    expect(
+      diagnostics.filter((d) => {
+        return d.kind === 'InvalidValue' && d.operator === 'in';
+      }).length,
+    ).toBeGreaterThanOrEqual(2); // 'abc' and '' both invalid
+  });
+
+  it('empty search yields empty filters & no diagnostics', () => {
+    const schema = defineSchema({ title: stringField(['contains']) });
+    const { filters, diagnostics } = parse('', schema);
+    expect(filters).toEqual({});
+    expect(diagnostics).toEqual([]);
+  });
+});

package/src/__tests__/schema-infer.test-d.ts

@@ -0,0 +1,24 @@
+import { defineSchema, numberField, stringField } from '../schema.js';
+import type { InferFilters } from '../types.js';
+
+export const schema = defineSchema({
+  price: numberField(['gt', 'between']),
+  title: stringField(['contains', 'in']),
+});
+
+type F = InferFilters<typeof schema>;
+
+// valid usages
+const a: F = { price: { gt: 1 }, title: { contains: 'x' } };
+const b: F = { price: { between: [1, 2] as const } }; // ok
+
+const c: F = { price: { in: [1, 2] } };
+// @ts-expect-error wrong tuple arity
+const d: F = { price: { between: [1, 2, 3] } };
+// @ts-expect-error wrong type
+const e: F = { price: { gt: 'nope' } };
+// @ts-expect-error missing array for list operator
+const f: F = { title: { in: 'x' } };
+
+// force usage to avoid unused variable errors
+export const _examples = { a, b, c, d, e, f };

package/src/__tests__/stability-and-diagnostics.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { defineSchema, numberField, stringField } from '../schema.js';
+import { parse } from '../parse.js';
+import { setFilter, mergeFilters } from '../mutate.js';
+
+const schema = defineSchema({
+  price: numberField(),
+  title: stringField(),
+});
+
+describe('reference stability & combined diagnostics', () => {
+  it('setFilter preserves reference when setting identical value again', () => {
+    const empty = parse('', schema).filters;
+    const f1 = setFilter(empty, schema, 'price', 'gt', 10);
+    expect(f1).not.toBe(empty);
+    const f2 = setFilter(f1, schema, 'price', 'gt', 10);
+    expect(f2).toBe(f1); // identical value no change
+    const f3 = setFilter(f2, schema, 'price', 'lte', 20);
+    expect(f3).not.toBe(f2);
+    // mergeFilters with empty patch returns same reference
+    const m1 = mergeFilters(f3, {} as any); // patch brings nothing
+    expect(m1).toBe(f3);
+    // mergeFilters with identical field object also preserves root
+    const patchSame = { price: f3.price } as any;
+    const m2 = mergeFilters(f3, patchSame);
+    expect(m2).toBe(f3);
+  });
+
+  it('reports UnknownField and UnknownOperator in same parse plus other diagnostics', () => {
+    const q = 'unknown.gt=5&price.xyz=10&price.gte=abc';
+    const { diagnostics } = parse(q, schema);
+    // collect kinds
+    const kinds = diagnostics.map((d) => {
+      return d.kind;
+    });
+    expect(kinds).toContain('UnknownField');
+    expect(kinds).toContain('UnknownOperator');
+    expect(kinds).toContain('InvalidValue'); // abc invalid number
+  });
+});

package/src/errors.ts

@@ -0,0 +1,46 @@
+export type Diagnostic =
+  | UnknownFieldDiagnostic
+  | UnknownOperatorDiagnostic
+  | InvalidValueDiagnostic
+  | InvalidArityDiagnostic
+  | DuplicateBetweenDiagnostic
+  | DecodeErrorDiagnostic;
+
+export interface BaseDiagnostic {
+  readonly kind: string;
+  readonly field?: string;
+  readonly operator?: string;
+  readonly detail?: string;
+}
+
+export interface UnknownFieldDiagnostic extends BaseDiagnostic {
+  kind: 'UnknownField';
+  field: string;
+}
+export interface UnknownOperatorDiagnostic extends BaseDiagnostic {
+  kind: 'UnknownOperator';
+  field: string;
+  operator: string;
+}
+export interface InvalidValueDiagnostic extends BaseDiagnostic {
+  kind: 'InvalidValue';
+  field: string;
+  operator: string;
+  detail?: string;
+}
+export interface InvalidArityDiagnostic extends BaseDiagnostic {
+  kind: 'InvalidArity';
+  field: string;
+  operator: string;
+  detail: string; // expected arity info
+}
+export interface DuplicateBetweenDiagnostic extends BaseDiagnostic {
+  kind: 'DuplicateBetween';
+  field: string;
+}
+export interface DecodeErrorDiagnostic extends BaseDiagnostic {
+  kind: 'DecodeError';
+  field: string;
+  operator: string;
+  detail: string;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export type * from './types.js';
+export * from './schema.js';
+export type * from './errors.js';
+export * from './parse.js';
+export * from './stringify.js';
+export * from './mutate.js';