@entifix/core 0.1.0-0

package/dist/i18n/negotiate.d.ts

@@ -0,0 +1,39 @@
+import { type Locale } from './locales.js';
+export interface LocalePath {
+    /** The locale carried by the path's first segment, if it names one. */
+    readonly locale?: Locale;
+    /** The path with that segment removed. Always starts with `/`. */
+    readonly rest: string;
+}
+/**
+ * Splits `/es/catalog/product` into `{ locale: 'es', rest: '/catalog/product' }`.
+ * A path whose first segment is not a locale comes back untouched, which is how
+ * the middleware tells "needs a redirect" from "needs a rewrite".
+ */
+export declare function splitLocalePath(pathname: string): LocalePath;
+/**
+ * Prefixes an in-app href with a locale. Absolute URLs and already-prefixed
+ * paths are returned as-is so this is safe to apply blindly at every call site
+ * — which is the point, since a single unprefixed `href` would bounce the user
+ * through a redirect and lose their place.
+ */
+export declare function localeHref(locale: Locale, href: string): string;
+/**
+ * Picks the best supported locale out of an `Accept-Language` header, honouring
+ * q-values and matching `es-419`/`es-MX` onto `es`. Returns `undefined` when the
+ * header names nothing we speak, so the caller can fall through to its default.
+ */
+export declare function parseAcceptLanguage(header: string | null | undefined): Locale | undefined;
+export interface NegotiateLocaleInput {
+    readonly pathname?: string;
+    readonly cookie?: string | null;
+    readonly acceptLanguage?: string | null;
+}
+/**
+ * The one place the precedence lives: an explicit path prefix beats the visitor's
+ * remembered choice, which beats what their browser asks for, which beats the
+ * fleet default. Pure, so the same function runs in edge middleware, in a server
+ * component and in a test.
+ */
+export declare function negotiateLocale({ pathname, cookie, acceptLanguage, }: NegotiateLocaleInput): Locale;
+//# sourceMappingURL=negotiate.d.ts.map

package/dist/i18n/negotiate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiate.d.ts","sourceRoot":"","sources":["../../src/i18n/negotiate.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAM5D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,MAAM,GAAG,SAAS,CA4BpB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,MAAM,EACN,cAAc,GACf,EAAE,oBAAoB,GAAG,MAAM,CAO/B"}

package/dist/i18n/negotiate.js

@@ -0,0 +1,63 @@
+import { DEFAULT_LOCALE, isLocale } from './locales.js';
+/**
+ * Splits `/es/catalog/product` into `{ locale: 'es', rest: '/catalog/product' }`.
+ * A path whose first segment is not a locale comes back untouched, which is how
+ * the middleware tells "needs a redirect" from "needs a rewrite".
+ */ export function splitLocalePath(pathname) {
+    const [, first = '', ...others] = pathname.split('/');
+    if (!isLocale(first)) return {
+        rest: pathname === '' ? '/' : pathname
+    };
+    const rest = others.join('/');
+    return {
+        locale: first,
+        rest: `/${rest}`
+    };
+}
+/**
+ * Prefixes an in-app href with a locale. Absolute URLs and already-prefixed
+ * paths are returned as-is so this is safe to apply blindly at every call site
+ * — which is the point, since a single unprefixed `href` would bounce the user
+ * through a redirect and lose their place.
+ */ export function localeHref(locale, href) {
+    if (/^[a-z][a-z0-9+.-]*:|^\/\//i.test(href)) return href;
+    if (!href.startsWith('/')) return href;
+    if (splitLocalePath(href).locale !== undefined) return href;
+    return href === '/' ? `/${locale}` : `/${locale}${href}`;
+}
+/**
+ * Picks the best supported locale out of an `Accept-Language` header, honouring
+ * q-values and matching `es-419`/`es-MX` onto `es`. Returns `undefined` when the
+ * header names nothing we speak, so the caller can fall through to its default.
+ */ export function parseAcceptLanguage(header) {
+    if (!header) return undefined;
+    const ranked = header.split(',').map((part)=>{
+        const [tag = '', ...params] = part.trim().split(';');
+        // A `q` that is present but unparseable makes the entry malformed rather
+        // than top-priority — the `NaN` is filtered out below.
+        const q = params.find((param)=>/^\s*q=/i.test(param));
+        return {
+            tag: tag.trim().toLowerCase(),
+            quality: q === undefined ? 1 : Number(q.trim().slice(2))
+        };
+    }).filter((entry)=>entry.tag !== '' && !Number.isNaN(entry.quality) && entry.quality > 0).sort((left, right)=>right.quality - left.quality);
+    for (const { tag } of ranked){
+        const base = tag.split('-')[0];
+        if (isLocale(base)) return base;
+    }
+    return undefined;
+}
+/**
+ * The one place the precedence lives: an explicit path prefix beats the visitor's
+ * remembered choice, which beats what their browser asks for, which beats the
+ * fleet default. Pure, so the same function runs in edge middleware, in a server
+ * component and in a test.
+ */ export function negotiateLocale({ pathname, cookie, acceptLanguage }) {
+    var _parseAcceptLanguage;
+    const fromPath = pathname === undefined ? undefined : splitLocalePath(pathname).locale;
+    if (fromPath !== undefined) return fromPath;
+    if (isLocale(cookie)) return cookie;
+    return (_parseAcceptLanguage = parseAcceptLanguage(acceptLanguage)) != null ? _parseAcceptLanguage : DEFAULT_LOCALE;
+}
+
+//# sourceMappingURL=negotiate.js.map

package/dist/i18n/negotiate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/negotiate.ts"],"sourcesContent":["import { DEFAULT_LOCALE, isLocale, type Locale } from './locales.js';\n\nexport interface LocalePath {\n  /** The locale carried by the path's first segment, if it names one. */\n  readonly locale?: Locale;\n  /** The path with that segment removed. Always starts with `/`. */\n  readonly rest: string;\n}\n\n/**\n * Splits `/es/catalog/product` into `{ locale: 'es', rest: '/catalog/product' }`.\n * A path whose first segment is not a locale comes back untouched, which is how\n * the middleware tells \"needs a redirect\" from \"needs a rewrite\".\n */\nexport function splitLocalePath(pathname: string): LocalePath {\n  const [, first = '', ...others] = pathname.split('/');\n  if (!isLocale(first)) return { rest: pathname === '' ? '/' : pathname };\n\n  const rest = others.join('/');\n  return { locale: first, rest: `/${rest}` };\n}\n\n/**\n * Prefixes an in-app href with a locale. Absolute URLs and already-prefixed\n * paths are returned as-is so this is safe to apply blindly at every call site\n * — which is the point, since a single unprefixed `href` would bounce the user\n * through a redirect and lose their place.\n */\nexport function localeHref(locale: Locale, href: string): string {\n  if (/^[a-z][a-z0-9+.-]*:|^\\/\\//i.test(href)) return href;\n  if (!href.startsWith('/')) return href;\n  if (splitLocalePath(href).locale !== undefined) return href;\n\n  return href === '/' ? `/${locale}` : `/${locale}${href}`;\n}\n\n/**\n * Picks the best supported locale out of an `Accept-Language` header, honouring\n * q-values and matching `es-419`/`es-MX` onto `es`. Returns `undefined` when the\n * header names nothing we speak, so the caller can fall through to its default.\n */\nexport function parseAcceptLanguage(\n  header: string | null | undefined,\n): Locale | undefined {\n  if (!header) return undefined;\n\n  const ranked = header\n    .split(',')\n    .map(part => {\n      const [tag = '', ...params] = part.trim().split(';');\n      // A `q` that is present but unparseable makes the entry malformed rather\n      // than top-priority — the `NaN` is filtered out below.\n      const q = params.find(param => /^\\s*q=/i.test(param));\n\n      return {\n        tag: tag.trim().toLowerCase(),\n        quality: q === undefined ? 1 : Number(q.trim().slice(2)),\n      };\n    })\n    .filter(\n      entry =>\n        entry.tag !== '' && !Number.isNaN(entry.quality) && entry.quality > 0,\n    )\n    .sort((left, right) => right.quality - left.quality);\n\n  for (const { tag } of ranked) {\n    const base = tag.split('-')[0];\n    if (isLocale(base)) return base;\n  }\n\n  return undefined;\n}\n\nexport interface NegotiateLocaleInput {\n  readonly pathname?: string;\n  readonly cookie?: string | null;\n  readonly acceptLanguage?: string | null;\n}\n\n/**\n * The one place the precedence lives: an explicit path prefix beats the visitor's\n * remembered choice, which beats what their browser asks for, which beats the\n * fleet default. Pure, so the same function runs in edge middleware, in a server\n * component and in a test.\n */\nexport function negotiateLocale({\n  pathname,\n  cookie,\n  acceptLanguage,\n}: NegotiateLocaleInput): Locale {\n  const fromPath =\n    pathname === undefined ? undefined : splitLocalePath(pathname).locale;\n  if (fromPath !== undefined) return fromPath;\n  if (isLocale(cookie)) return cookie;\n\n  return parseAcceptLanguage(acceptLanguage) ?? DEFAULT_LOCALE;\n}\n"],"names":["DEFAULT_LOCALE","isLocale","splitLocalePath","pathname","first","others","split","rest","join","locale","localeHref","href","test","startsWith","undefined","parseAcceptLanguage","header","ranked","map","part","tag","params","trim","q","find","param","toLowerCase","quality","Number","slice","filter","entry","isNaN","sort","left","right","base","negotiateLocale","cookie","acceptLanguage","fromPath"],"mappings":"AAAA,SAASA,cAAc,EAAEC,QAAQ,QAAqB,eAAe;AASrE;;;;CAIC,GACD,OAAO,SAASC,gBAAgBC,QAAgB;IAC9C,MAAM,GAAGC,QAAQ,EAAE,EAAE,GAAGC,OAAO,GAAGF,SAASG,KAAK,CAAC;IACjD,IAAI,CAACL,SAASG,QAAQ,OAAO;QAAEG,MAAMJ,aAAa,KAAK,MAAMA;IAAS;IAEtE,MAAMI,OAAOF,OAAOG,IAAI,CAAC;IACzB,OAAO;QAAEC,QAAQL;QAAOG,MAAM,CAAC,CAAC,EAAEA,MAAM;IAAC;AAC3C;AAEA;;;;;CAKC,GACD,OAAO,SAASG,WAAWD,MAAc,EAAEE,IAAY;IACrD,IAAI,6BAA6BC,IAAI,CAACD,OAAO,OAAOA;IACpD,IAAI,CAACA,KAAKE,UAAU,CAAC,MAAM,OAAOF;IAClC,IAAIT,gBAAgBS,MAAMF,MAAM,KAAKK,WAAW,OAAOH;IAEvD,OAAOA,SAAS,MAAM,CAAC,CAAC,EAAEF,QAAQ,GAAG,CAAC,CAAC,EAAEA,SAASE,MAAM;AAC1D;AAEA;;;;CAIC,GACD,OAAO,SAASI,oBACdC,MAAiC;IAEjC,IAAI,CAACA,QAAQ,OAAOF;IAEpB,MAAMG,SAASD,OACZV,KAAK,CAAC,KACNY,GAAG,CAACC,CAAAA;QACH,MAAM,CAACC,MAAM,EAAE,EAAE,GAAGC,OAAO,GAAGF,KAAKG,IAAI,GAAGhB,KAAK,CAAC;QAChD,yEAAyE;QACzE,uDAAuD;QACvD,MAAMiB,IAAIF,OAAOG,IAAI,CAACC,CAAAA,QAAS,UAAUb,IAAI,CAACa;QAE9C,OAAO;YACLL,KAAKA,IAAIE,IAAI,GAAGI,WAAW;YAC3BC,SAASJ,MAAMT,YAAY,IAAIc,OAAOL,EAAED,IAAI,GAAGO,KAAK,CAAC;QACvD;IACF,GACCC,MAAM,CACLC,CAAAA,QACEA,MAAMX,GAAG,KAAK,MAAM,CAACQ,OAAOI,KAAK,CAACD,MAAMJ,OAAO,KAAKI,MAAMJ,OAAO,GAAG,GAEvEM,IAAI,CAAC,CAACC,MAAMC,QAAUA,MAAMR,OAAO,GAAGO,KAAKP,OAAO;IAErD,KAAK,MAAM,EAAEP,GAAG,EAAE,IAAIH,OAAQ;QAC5B,MAAMmB,OAAOhB,IAAId,KAAK,CAAC,IAAI,CAAC,EAAE;QAC9B,IAAIL,SAASmC,OAAO,OAAOA;IAC7B;IAEA,OAAOtB;AACT;AAQA;;;;;CAKC,GACD,OAAO,SAASuB,gBAAgB,EAC9BlC,QAAQ,EACRmC,MAAM,EACNC,cAAc,EACO;QAMdxB;IALP,MAAMyB,WACJrC,aAAaW,YAAYA,YAAYZ,gBAAgBC,UAAUM,MAAM;IACvE,IAAI+B,aAAa1B,WAAW,OAAO0B;IACnC,IAAIvC,SAASqC,SAAS,OAAOA;IAE7B,QAAOvB,uBAAAA,oBAAoBwB,2BAApBxB,uBAAuCf;AAChD"}

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+export * from './base-entities/configuration-client/index.js';
+export * from './base-entities/entifix-error/index.js';
+export * from './command-palette/index.js';
+export * from './entity-definition/decorators/accessor/index.js';
+export * from './entity-definition/decorators/entity/index.js';
+export * from './entity-definition/decorators/method/index.js';
+export * from './entity-definition/decorators/use-case/index.js';
+export * from './entity-definition/describe/index.js';
+export * from './entity-definition/field-path.js';
+export * from './entity-definition/helpers/index.js';
+export * from './entity-definition/links/apply-entity-links/index.js';
+export * from './entity-definition/links/entity-collection-link/index.js';
+export * from './entity-definition/links/entity-link/index.js';
+export * from './entity-definition/links/entity-link-source/index.js';
+export * from './entity-definition/meta-entities/meta-accessor/index.js';
+export * from './entity-definition/meta-entities/meta-entity/index.js';
+export * from './entity-definition/meta-entities/meta-method/index.js';
+export * from './entity-definition/meta-entities/meta-use-case/index.js';
+export * from './entity-definition/metadata/index.js';
+export * from './entity-definition/reconstruct/index.js';
+export * from './entity-definition/serializer/index.js';
+export * from './envelope/index.js';
+export * from './http/session-cookies.js';
+export * from './i18n/format.js';
+export * from './i18n/locales.js';
+export * from './i18n/negotiate.js';
+export * from './rsql/index.js';
+export * from './types/BulkOutcome.js';
+export * from './types/Entity.js';
+export * from './types/EntityAction.js';
+export * from './types/EntityDraft.js';
+export * from './types/EntityFiltering.js';
+export * from './types/EntityLoadRequest.js';
+export * from './types/EntityPage.js';
+export * from './types/EntityRowDraft.js';
+export * from './types/EntitySelection.js';
+export * from './types/EntitySorting.js';
+export * from './types/Json.js';
+export * from './types/StandardSchema.js';
+export * from './types/UseCase.js';
+export * from './wizard/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC;AACvD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kDAAkD,CAAC;AACjE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,uDAAuD,CAAC;AACtE,cAAc,2DAA2D,CAAC;AAC1E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,0DAA0D,CAAC;AACzE,cAAc,wDAAwD,CAAC;AACvE,cAAc,wDAAwD,CAAC;AACvE,cAAc,0DAA0D,CAAC;AACzE,cAAc,uCAAuC,CAAC;AACtD,cAAc,0CAA0C,CAAC;AACzD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,43 @@
+export * from './base-entities/configuration-client/index.js';
+export * from './base-entities/entifix-error/index.js';
+export * from './command-palette/index.js';
+export * from './entity-definition/decorators/accessor/index.js';
+export * from './entity-definition/decorators/entity/index.js';
+export * from './entity-definition/decorators/method/index.js';
+export * from './entity-definition/decorators/use-case/index.js';
+export * from './entity-definition/describe/index.js';
+export * from './entity-definition/field-path.js';
+export * from './entity-definition/helpers/index.js';
+export * from './entity-definition/links/apply-entity-links/index.js';
+export * from './entity-definition/links/entity-collection-link/index.js';
+export * from './entity-definition/links/entity-link/index.js';
+export * from './entity-definition/links/entity-link-source/index.js';
+export * from './entity-definition/meta-entities/meta-accessor/index.js';
+export * from './entity-definition/meta-entities/meta-entity/index.js';
+export * from './entity-definition/meta-entities/meta-method/index.js';
+export * from './entity-definition/meta-entities/meta-use-case/index.js';
+export * from './entity-definition/metadata/index.js';
+export * from './entity-definition/reconstruct/index.js';
+export * from './entity-definition/serializer/index.js';
+export * from './envelope/index.js';
+export * from './http/session-cookies.js';
+export * from './i18n/format.js';
+export * from './i18n/locales.js';
+export * from './i18n/negotiate.js';
+export * from './rsql/index.js';
+export * from './types/BulkOutcome.js';
+export * from './types/Entity.js';
+export * from './types/EntityAction.js';
+export * from './types/EntityDraft.js';
+export * from './types/EntityFiltering.js';
+export * from './types/EntityLoadRequest.js';
+export * from './types/EntityPage.js';
+export * from './types/EntityRowDraft.js';
+export * from './types/EntitySelection.js';
+export * from './types/EntitySorting.js';
+export * from './types/Json.js';
+export * from './types/StandardSchema.js';
+export * from './types/UseCase.js';
+export * from './wizard/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './base-entities/configuration-client/index.js';\nexport * from './base-entities/entifix-error/index.js';\nexport * from './command-palette/index.js';\nexport * from './entity-definition/decorators/accessor/index.js';\nexport * from './entity-definition/decorators/entity/index.js';\nexport * from './entity-definition/decorators/method/index.js';\nexport * from './entity-definition/decorators/use-case/index.js';\nexport * from './entity-definition/describe/index.js';\nexport * from './entity-definition/field-path.js';\nexport * from './entity-definition/helpers/index.js';\nexport * from './entity-definition/links/apply-entity-links/index.js';\nexport * from './entity-definition/links/entity-collection-link/index.js';\nexport * from './entity-definition/links/entity-link/index.js';\nexport * from './entity-definition/links/entity-link-source/index.js';\nexport * from './entity-definition/meta-entities/meta-accessor/index.js';\nexport * from './entity-definition/meta-entities/meta-entity/index.js';\nexport * from './entity-definition/meta-entities/meta-method/index.js';\nexport * from './entity-definition/meta-entities/meta-use-case/index.js';\nexport * from './entity-definition/metadata/index.js';\nexport * from './entity-definition/reconstruct/index.js';\nexport * from './entity-definition/serializer/index.js';\nexport * from './envelope/index.js';\nexport * from './http/session-cookies.js';\nexport * from './i18n/format.js';\nexport * from './i18n/locales.js';\nexport * from './i18n/negotiate.js';\nexport * from './rsql/index.js';\nexport * from './types/BulkOutcome.js';\nexport * from './types/Entity.js';\nexport * from './types/EntityAction.js';\nexport * from './types/EntityDraft.js';\nexport * from './types/EntityFiltering.js';\nexport * from './types/EntityLoadRequest.js';\nexport * from './types/EntityPage.js';\nexport * from './types/EntityRowDraft.js';\nexport * from './types/EntitySelection.js';\nexport * from './types/EntitySorting.js';\nexport * from './types/Json.js';\nexport * from './types/StandardSchema.js';\nexport * from './types/UseCase.js';\nexport * from './wizard/index.js';\n"],"names":[],"mappings":"AAAA,cAAc,gDAAgD;AAC9D,cAAc,yCAAyC;AACvD,cAAc,6BAA6B;AAC3C,cAAc,mDAAmD;AACjE,cAAc,iDAAiD;AAC/D,cAAc,iDAAiD;AAC/D,cAAc,mDAAmD;AACjE,cAAc,wCAAwC;AACtD,cAAc,oCAAoC;AAClD,cAAc,uCAAuC;AACrD,cAAc,wDAAwD;AACtE,cAAc,4DAA4D;AAC1E,cAAc,iDAAiD;AAC/D,cAAc,wDAAwD;AACtE,cAAc,2DAA2D;AACzE,cAAc,yDAAyD;AACvE,cAAc,yDAAyD;AACvE,cAAc,2DAA2D;AACzE,cAAc,wCAAwC;AACtD,cAAc,2CAA2C;AACzD,cAAc,0CAA0C;AACxD,cAAc,sBAAsB;AACpC,cAAc,4BAA4B;AAC1C,cAAc,mBAAmB;AACjC,cAAc,oBAAoB;AAClC,cAAc,sBAAsB;AACpC,cAAc,kBAAkB;AAChC,cAAc,yBAAyB;AACvC,cAAc,oBAAoB;AAClC,cAAc,0BAA0B;AACxC,cAAc,yBAAyB;AACvC,cAAc,6BAA6B;AAC3C,cAAc,+BAA+B;AAC7C,cAAc,wBAAwB;AACtC,cAAc,4BAA4B;AAC1C,cAAc,6BAA6B;AAC3C,cAAc,2BAA2B;AACzC,cAAc,kBAAkB;AAChC,cAAc,4BAA4B;AAC1C,cAAc,qBAAqB;AACnC,cAAc,oBAAoB"}

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

@@ -0,0 +1,27 @@
+import { type EntityFieldDescriptor } from '../entity-definition/describe/index.js';
+import type { Entity, EntityConstructor } from '../types/Entity.js';
+import type { FilterGroup } from '../types/EntityFiltering.js';
+import { type RawFilterGroup } from './parse-rsql.js';
+/**
+ * Resolves the members a client is allowed to name, keyed by both the accessor
+ * name and its wire key so a URL may use either.
+ *
+ * `select` is what makes this an allowlist rather than a lookup: a member the
+ * entity did not mark `filterable`/`sortable` is simply not in the map, and a
+ * request naming it is rejected. That is the guard against a client filtering
+ * on a `hidden` member or an unindexed one.
+ */
+export declare function allowedDescriptors<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, select: (descriptor: EntityFieldDescriptor) => boolean): Map<string, EntityFieldDescriptor>;
+/**
+ * Turns a parsed, untyped RSQL tree into a typed {@link FilterGroup} the
+ * repositories can execute, validating it against the entity's metadata on the
+ * way through.
+ *
+ * This is the trust boundary of the query protocol. Everything before it is a
+ * string a client chose; everything after it names only members the entity
+ * declared `filterable` and carries only values of those members' declared
+ * types. A violation throws {@link EntifixBuildError}, which services already
+ * map to a `400`.
+ */
+export declare function coerceFiltering<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, parsed: RawFilterGroup): FilterGroup<TEntity>;
+//# sourceMappingURL=coerce-rsql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coerce-rsql.d.ts","sourceRoot":"","sources":["../../src/rsql/coerce-rsql.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,wCAAwC,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,SAAS,MAAM,EACvD,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,MAAM,EAAE,CAAC,UAAU,EAAE,qBAAqB,KAAK,OAAO,GACrD,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAQpC;AA8FD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,MAAM,EACpD,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,MAAM,EAAE,cAAc,GACrB,WAAW,CAAC,OAAO,CAAC,CAUtB"}

package/dist/rsql/coerce-rsql.js

@@ -0,0 +1,121 @@
+import { EntifixBuildError } from '../base-entities/entifix-error/index.js';
+import { describeEntityColumns } from '../entity-definition/describe/index.js';
+import { isRawFilter } from './parse-rsql.js';
+/**
+ * Resolves the members a client is allowed to name, keyed by both the accessor
+ * name and its wire key so a URL may use either.
+ *
+ * `select` is what makes this an allowlist rather than a lookup: a member the
+ * entity did not mark `filterable`/`sortable` is simply not in the map, and a
+ * request naming it is rejected. That is the guard against a client filtering
+ * on a `hidden` member or an unindexed one.
+ */ export function allowedDescriptors(entityConstructor, select) {
+    const allowed = new Map();
+    for (const descriptor of describeEntityColumns(entityConstructor)){
+        if (!select(descriptor)) continue;
+        allowed.set(descriptor.name, descriptor);
+        allowed.set(descriptor.key, descriptor);
+    }
+    return allowed;
+}
+const reject = (message, details)=>new EntifixBuildError(message, undefined, details);
+/** Re-types one raw argument from the member's declared type. */ function coerceValue(raw, descriptor) {
+    switch(descriptor.type){
+        case 'number':
+            {
+                const value = Number(raw);
+                if (raw.trim() === '' || Number.isNaN(value)) {
+                    throw reject(`"${raw}" is not a number for "${descriptor.name}"`);
+                }
+                return value;
+            }
+        case 'boolean':
+            {
+                if (raw !== 'true' && raw !== 'false') {
+                    throw reject(`"${raw}" is not a boolean for "${descriptor.name}"`);
+                }
+                return raw === 'true';
+            }
+        case 'date':
+            {
+                const value = new Date(raw);
+                if (Number.isNaN(value.getTime())) {
+                    throw reject(`"${raw}" is not a date for "${descriptor.name}"`);
+                }
+                return value;
+            }
+        case 'enum':
+            {
+                if (descriptor.enumValues && !descriptor.enumValues.includes(raw)) {
+                    throw reject(`"${raw}" is not a value of "${descriptor.name}"`);
+                }
+                return raw;
+            }
+        default:
+            return raw;
+    }
+}
+function coerceFilter(raw, allowed) {
+    const descriptor = allowed.get(raw.property);
+    if (!descriptor) {
+        throw reject(`"${raw.property}" is not a filterable member`, {
+            property: raw.property
+        });
+    }
+    // The wire key is also the stored field name, so this is what the Mongo
+    // translator downstream will use.
+    const property = descriptor.key;
+    const coerce = (value)=>coerceValue(value, descriptor);
+    if (raw.values) {
+        return {
+            property,
+            operator: raw.operator,
+            values: raw.values.map(coerce)
+        };
+    }
+    if (raw.start !== undefined && raw.end !== undefined) {
+        return {
+            property,
+            operator: raw.operator,
+            start: coerce(raw.start),
+            end: coerce(raw.end)
+        };
+    }
+    if (raw.value !== undefined) {
+        return {
+            property,
+            operator: raw.operator,
+            value: coerce(raw.value)
+        };
+    }
+    // `isNull`/`isNotNull` — no argument to coerce.
+    return {
+        property,
+        operator: raw.operator
+    };
+}
+function coerceNode(node, allowed) {
+    return isRawFilter(node) ? coerceFilter(node, allowed) : {
+        operator: node.operator,
+        values: node.values.map((child)=>coerceNode(child, allowed))
+    };
+}
+/**
+ * Turns a parsed, untyped RSQL tree into a typed {@link FilterGroup} the
+ * repositories can execute, validating it against the entity's metadata on the
+ * way through.
+ *
+ * This is the trust boundary of the query protocol. Everything before it is a
+ * string a client chose; everything after it names only members the entity
+ * declared `filterable` and carries only values of those members' declared
+ * types. A violation throws {@link EntifixBuildError}, which services already
+ * map to a `400`.
+ */ export function coerceFiltering(entityConstructor, parsed) {
+    const allowed = allowedDescriptors(entityConstructor, (descriptor)=>descriptor.filterable);
+    return {
+        operator: parsed.operator,
+        values: parsed.values.map((node)=>coerceNode(node, allowed))
+    };
+}
+
+//# sourceMappingURL=coerce-rsql.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/coerce-rsql.ts"],"sourcesContent":["import { EntifixBuildError } from '../base-entities/entifix-error/index.js';\nimport {\n  describeEntityColumns,\n  type EntityFieldDescriptor,\n} from '../entity-definition/describe/index.js';\nimport type { MetaAccessorType } from '../entity-definition/meta-entities/meta-accessor/index.js';\nimport type { Entity, EntityConstructor } from '../types/Entity.js';\nimport type { EntityFilter, FilterGroup } from '../types/EntityFiltering.js';\nimport {\n  isRawFilter,\n  type RawFilter,\n  type RawFilterGroup,\n} from './parse-rsql.js';\n\n/**\n * Resolves the members a client is allowed to name, keyed by both the accessor\n * name and its wire key so a URL may use either.\n *\n * `select` is what makes this an allowlist rather than a lookup: a member the\n * entity did not mark `filterable`/`sortable` is simply not in the map, and a\n * request naming it is rejected. That is the guard against a client filtering\n * on a `hidden` member or an unindexed one.\n */\nexport function allowedDescriptors<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  select: (descriptor: EntityFieldDescriptor) => boolean,\n): Map<string, EntityFieldDescriptor> {\n  const allowed = new Map<string, EntityFieldDescriptor>();\n  for (const descriptor of describeEntityColumns(entityConstructor)) {\n    if (!select(descriptor)) continue;\n    allowed.set(descriptor.name, descriptor);\n    allowed.set(descriptor.key, descriptor);\n  }\n  return allowed;\n}\n\nconst reject = (message: string, details?: Record<string, unknown>) =>\n  new EntifixBuildError(message, undefined, details);\n\n/** Re-types one raw argument from the member's declared type. */\nfunction coerceValue(raw: string, descriptor: EntityFieldDescriptor): unknown {\n  switch (descriptor.type as MetaAccessorType) {\n    case 'number': {\n      const value = Number(raw);\n      if (raw.trim() === '' || Number.isNaN(value)) {\n        throw reject(`\"${raw}\" is not a number for \"${descriptor.name}\"`);\n      }\n      return value;\n    }\n    case 'boolean': {\n      if (raw !== 'true' && raw !== 'false') {\n        throw reject(`\"${raw}\" is not a boolean for \"${descriptor.name}\"`);\n      }\n      return raw === 'true';\n    }\n    case 'date': {\n      const value = new Date(raw);\n      if (Number.isNaN(value.getTime())) {\n        throw reject(`\"${raw}\" is not a date for \"${descriptor.name}\"`);\n      }\n      return value;\n    }\n    case 'enum': {\n      if (descriptor.enumValues && !descriptor.enumValues.includes(raw)) {\n        throw reject(`\"${raw}\" is not a value of \"${descriptor.name}\"`);\n      }\n      return raw;\n    }\n    default:\n      return raw;\n  }\n}\n\nfunction coerceFilter<TEntity extends Entity>(\n  raw: RawFilter,\n  allowed: Map<string, EntityFieldDescriptor>,\n): EntityFilter<TEntity> {\n  const descriptor = allowed.get(raw.property);\n  if (!descriptor) {\n    throw reject(`\"${raw.property}\" is not a filterable member`, {\n      property: raw.property,\n    });\n  }\n\n  // The wire key is also the stored field name, so this is what the Mongo\n  // translator downstream will use.\n  const property = descriptor.key as keyof TEntity;\n  const coerce = (value: string) => coerceValue(value, descriptor);\n\n  if (raw.values) {\n    return {\n      property,\n      operator: raw.operator,\n      values: raw.values.map(coerce),\n    } as EntityFilter<TEntity>;\n  }\n  if (raw.start !== undefined && raw.end !== undefined) {\n    return {\n      property,\n      operator: raw.operator,\n      start: coerce(raw.start),\n      end: coerce(raw.end),\n    } as EntityFilter<TEntity>;\n  }\n  if (raw.value !== undefined) {\n    return {\n      property,\n      operator: raw.operator,\n      value: coerce(raw.value),\n    } as EntityFilter<TEntity>;\n  }\n\n  // `isNull`/`isNotNull` — no argument to coerce.\n  return { property, operator: raw.operator } as EntityFilter<TEntity>;\n}\n\nfunction coerceNode<TEntity extends Entity>(\n  node: RawFilter | RawFilterGroup,\n  allowed: Map<string, EntityFieldDescriptor>,\n): EntityFilter<TEntity> | FilterGroup<TEntity> {\n  return isRawFilter(node)\n    ? coerceFilter<TEntity>(node, allowed)\n    : {\n        operator: node.operator,\n        values: node.values.map(child => coerceNode<TEntity>(child, allowed)),\n      };\n}\n\n/**\n * Turns a parsed, untyped RSQL tree into a typed {@link FilterGroup} the\n * repositories can execute, validating it against the entity's metadata on the\n * way through.\n *\n * This is the trust boundary of the query protocol. Everything before it is a\n * string a client chose; everything after it names only members the entity\n * declared `filterable` and carries only values of those members' declared\n * types. A violation throws {@link EntifixBuildError}, which services already\n * map to a `400`.\n */\nexport function coerceFiltering<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  parsed: RawFilterGroup,\n): FilterGroup<TEntity> {\n  const allowed = allowedDescriptors(\n    entityConstructor,\n    descriptor => descriptor.filterable,\n  );\n\n  return {\n    operator: parsed.operator,\n    values: parsed.values.map(node => coerceNode<TEntity>(node, allowed)),\n  };\n}\n"],"names":["EntifixBuildError","describeEntityColumns","isRawFilter","allowedDescriptors","entityConstructor","select","allowed","Map","descriptor","set","name","key","reject","message","details","undefined","coerceValue","raw","type","value","Number","trim","isNaN","Date","getTime","enumValues","includes","coerceFilter","get","property","coerce","values","operator","map","start","end","coerceNode","node","child","coerceFiltering","parsed","filterable"],"mappings":"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"}

package/dist/rsql/index.d.ts

@@ -0,0 +1,8 @@
+export * from './coerce-rsql.js';
+export * from './load-request-url.js';
+export * from './parse-rsql.js';
+export * from './rsql-operators.js';
+export * from './rsql-values.js';
+export * from './serialize-rsql.js';
+export * from './sort-param.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rsql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rsql/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/rsql/index.js

@@ -0,0 +1,9 @@
+export * from './coerce-rsql.js';
+export * from './load-request-url.js';
+export * from './parse-rsql.js';
+export * from './rsql-operators.js';
+export * from './rsql-values.js';
+export * from './serialize-rsql.js';
+export * from './sort-param.js';
+
+//# sourceMappingURL=index.js.map

package/dist/rsql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/index.ts"],"sourcesContent":["export * from './coerce-rsql.js';\nexport * from './load-request-url.js';\nexport * from './parse-rsql.js';\nexport * from './rsql-operators.js';\nexport * from './rsql-values.js';\nexport * from './serialize-rsql.js';\nexport * from './sort-param.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB;AACjC,cAAc,wBAAwB;AACtC,cAAc,kBAAkB;AAChC,cAAc,sBAAsB;AACpC,cAAc,mBAAmB;AACjC,cAAc,sBAAsB;AACpC,cAAc,kBAAkB"}

package/dist/rsql/load-request-url.d.ts

@@ -0,0 +1,30 @@
+import type { Entity, EntityConstructor } from '../types/Entity.js';
+import type { EntityLoadRequest } from '../types/EntityLoadRequest.js';
+/** The query parameters a load request is expressed in. */
+export declare const RSQL_PARAM = "rsql";
+export declare const SORT_PARAM = "sort";
+export declare const PAGE_PARAM = "page";
+export declare const PAGE_SIZE_PARAM = "pageSize";
+export interface LoadRequestDefaults {
+    page: number;
+    pageSize: number;
+    /** Upper bound on `pageSize`, so a client cannot ask for the whole table. */
+    maxPageSize?: number;
+}
+/**
+ * Serializes a load request into query parameters. Empty filtering, empty
+ * sorting and absent paging are all omitted rather than sent blank, so a plain
+ * listing keeps a clean URL.
+ */
+export declare function serializeLoadRequestParams<TEntity extends Entity>(request: EntityLoadRequest<TEntity>): URLSearchParams;
+/**
+ * Parses query parameters into an {@link EntityLoadRequest}, validated against
+ * the entity's own metadata — the server-side half of the query protocol.
+ *
+ * Every failure mode (malformed RSQL, an unknown or non-filterable member, a
+ * value that is not of the member's type, a nonsense page) is an
+ * {@link EntifixBuildError}: the client sent something wrong, so it is a `400`
+ * and never a `500`.
+ */
+export declare function parseLoadRequestParams<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, params: URLSearchParams, defaults?: Partial<LoadRequestDefaults>): EntityLoadRequest<TEntity>;
+//# sourceMappingURL=load-request-url.d.ts.map

package/dist/rsql/load-request-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-request-url.d.ts","sourceRoot":"","sources":["../../src/rsql/load-request-url.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAMvE,2DAA2D;AAC3D,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,eAAe,aAAa,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAQD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,SAAS,MAAM,EAC/D,OAAO,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAClC,eAAe,CAejB;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,SAAS,MAAM,EAC3D,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,MAAM,EAAE,eAAe,EACvB,QAAQ,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC1C,iBAAiB,CAAC,OAAO,CAAC,CAsB5B"}

package/dist/rsql/load-request-url.js

@@ -0,0 +1,67 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntifixBuildError } from '../base-entities/entifix-error/index.js';
+import { coerceFiltering } from './coerce-rsql.js';
+import { parseRsql } from './parse-rsql.js';
+import { serializeRsql } from './serialize-rsql.js';
+import { parseSort, serializeSort } from './sort-param.js';
+/** The query parameters a load request is expressed in. */ export const RSQL_PARAM = 'rsql';
+export const SORT_PARAM = 'sort';
+export const PAGE_PARAM = 'page';
+export const PAGE_SIZE_PARAM = 'pageSize';
+const DEFAULTS = {
+    page: 1,
+    pageSize: 10,
+    maxPageSize: 200
+};
+/**
+ * Serializes a load request into query parameters. Empty filtering, empty
+ * sorting and absent paging are all omitted rather than sent blank, so a plain
+ * listing keeps a clean URL.
+ */ export function serializeLoadRequestParams(request) {
+    const params = new URLSearchParams();
+    const rsql = serializeRsql(request.filtering);
+    if (rsql !== '') params.set(RSQL_PARAM, rsql);
+    const sort = serializeSort(request.sorting);
+    if (sort !== '') params.set(SORT_PARAM, sort);
+    if (request.page != null) params.set(PAGE_PARAM, String(request.page));
+    if (request.pageSize != null) {
+        params.set(PAGE_SIZE_PARAM, String(request.pageSize));
+    }
+    return params;
+}
+/** Reads a positive integer parameter, falling back when absent or unusable. */ function readPositiveInteger(params, name, fallback) {
+    const raw = params.get(name);
+    if (raw === null || raw.trim() === '') return fallback;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new EntifixBuildError(`"${name}" must be a positive integer`, undefined, {
+            [name]: raw
+        });
+    }
+    return value;
+}
+/**
+ * Parses query parameters into an {@link EntityLoadRequest}, validated against
+ * the entity's own metadata — the server-side half of the query protocol.
+ *
+ * Every failure mode (malformed RSQL, an unknown or non-filterable member, a
+ * value that is not of the member's type, a nonsense page) is an
+ * {@link EntifixBuildError}: the client sent something wrong, so it is a `400`
+ * and never a `500`.
+ */ export function parseLoadRequestParams(entityConstructor, params, defaults = {}) {
+    const { page, pageSize, maxPageSize } = _extends({}, DEFAULTS, defaults);
+    const expression = params.get(RSQL_PARAM);
+    const filtering = (expression == null ? void 0 : expression.trim()) ? [
+        coerceFiltering(entityConstructor, parseRsql(expression))
+    ] : undefined;
+    const sorting = parseSort(entityConstructor, params.get(SORT_PARAM));
+    const request = {
+        page: readPositiveInteger(params, PAGE_PARAM, page),
+        pageSize: Math.min(readPositiveInteger(params, PAGE_SIZE_PARAM, pageSize), maxPageSize)
+    };
+    if (filtering) request.filtering = filtering;
+    if (sorting) request.sorting = sorting;
+    return request;
+}
+
+//# sourceMappingURL=load-request-url.js.map

package/dist/rsql/load-request-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/rsql/load-request-url.ts"],"sourcesContent":["import { EntifixBuildError } from '../base-entities/entifix-error/index.js';\nimport type { Entity, EntityConstructor } from '../types/Entity.js';\nimport type { EntityLoadRequest } from '../types/EntityLoadRequest.js';\nimport { coerceFiltering } from './coerce-rsql.js';\nimport { parseRsql } from './parse-rsql.js';\nimport { serializeRsql } from './serialize-rsql.js';\nimport { parseSort, serializeSort } from './sort-param.js';\n\n/** The query parameters a load request is expressed in. */\nexport const RSQL_PARAM = 'rsql';\nexport const SORT_PARAM = 'sort';\nexport const PAGE_PARAM = 'page';\nexport const PAGE_SIZE_PARAM = 'pageSize';\n\nexport interface LoadRequestDefaults {\n  page: number;\n  pageSize: number;\n  /** Upper bound on `pageSize`, so a client cannot ask for the whole table. */\n  maxPageSize?: number;\n}\n\nconst DEFAULTS: Required<LoadRequestDefaults> = {\n  page: 1,\n  pageSize: 10,\n  maxPageSize: 200,\n};\n\n/**\n * Serializes a load request into query parameters. Empty filtering, empty\n * sorting and absent paging are all omitted rather than sent blank, so a plain\n * listing keeps a clean URL.\n */\nexport function serializeLoadRequestParams<TEntity extends Entity>(\n  request: EntityLoadRequest<TEntity>,\n): URLSearchParams {\n  const params = new URLSearchParams();\n\n  const rsql = serializeRsql(request.filtering);\n  if (rsql !== '') params.set(RSQL_PARAM, rsql);\n\n  const sort = serializeSort(request.sorting);\n  if (sort !== '') params.set(SORT_PARAM, sort);\n\n  if (request.page != null) params.set(PAGE_PARAM, String(request.page));\n  if (request.pageSize != null) {\n    params.set(PAGE_SIZE_PARAM, String(request.pageSize));\n  }\n\n  return params;\n}\n\n/** Reads a positive integer parameter, falling back when absent or unusable. */\nfunction readPositiveInteger(\n  params: URLSearchParams,\n  name: string,\n  fallback: number,\n): number {\n  const raw = params.get(name);\n  if (raw === null || raw.trim() === '') return fallback;\n\n  const value = Number(raw);\n  if (!Number.isInteger(value) || value < 1) {\n    throw new EntifixBuildError(\n      `\"${name}\" must be a positive integer`,\n      undefined,\n      { [name]: raw },\n    );\n  }\n  return value;\n}\n\n/**\n * Parses query parameters into an {@link EntityLoadRequest}, validated against\n * the entity's own metadata — the server-side half of the query protocol.\n *\n * Every failure mode (malformed RSQL, an unknown or non-filterable member, a\n * value that is not of the member's type, a nonsense page) is an\n * {@link EntifixBuildError}: the client sent something wrong, so it is a `400`\n * and never a `500`.\n */\nexport function parseLoadRequestParams<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  params: URLSearchParams,\n  defaults: Partial<LoadRequestDefaults> = {},\n): EntityLoadRequest<TEntity> {\n  const { page, pageSize, maxPageSize } = { ...DEFAULTS, ...defaults };\n\n  const expression = params.get(RSQL_PARAM);\n  const filtering = expression?.trim()\n    ? [coerceFiltering(entityConstructor, parseRsql(expression))]\n    : undefined;\n\n  const sorting = parseSort(entityConstructor, params.get(SORT_PARAM));\n\n  const request: EntityLoadRequest<TEntity> = {\n    page: readPositiveInteger(params, PAGE_PARAM, page),\n    pageSize: Math.min(\n      readPositiveInteger(params, PAGE_SIZE_PARAM, pageSize),\n      maxPageSize,\n    ),\n  };\n\n  if (filtering) request.filtering = filtering;\n  if (sorting) request.sorting = sorting;\n\n  return request;\n}\n"],"names":["EntifixBuildError","coerceFiltering","parseRsql","serializeRsql","parseSort","serializeSort","RSQL_PARAM","SORT_PARAM","PAGE_PARAM","PAGE_SIZE_PARAM","DEFAULTS","page","pageSize","maxPageSize","serializeLoadRequestParams","request","params","URLSearchParams","rsql","filtering","set","sort","sorting","String","readPositiveInteger","name","fallback","raw","get","trim","value","Number","isInteger","undefined","parseLoadRequestParams","entityConstructor","defaults","expression","Math","min"],"mappings":";AAAA,SAASA,iBAAiB,QAAQ,0CAA0C;AAG5E,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,aAAa,QAAQ,sBAAsB;AACpD,SAASC,SAAS,EAAEC,aAAa,QAAQ,kBAAkB;AAE3D,yDAAyD,GACzD,OAAO,MAAMC,aAAa,OAAO;AACjC,OAAO,MAAMC,aAAa,OAAO;AACjC,OAAO,MAAMC,aAAa,OAAO;AACjC,OAAO,MAAMC,kBAAkB,WAAW;AAS1C,MAAMC,WAA0C;IAC9CC,MAAM;IACNC,UAAU;IACVC,aAAa;AACf;AAEA;;;;CAIC,GACD,OAAO,SAASC,2BACdC,OAAmC;IAEnC,MAAMC,SAAS,IAAIC;IAEnB,MAAMC,OAAOf,cAAcY,QAAQI,SAAS;IAC5C,IAAID,SAAS,IAAIF,OAAOI,GAAG,CAACd,YAAYY;IAExC,MAAMG,OAAOhB,cAAcU,QAAQO,OAAO;IAC1C,IAAID,SAAS,IAAIL,OAAOI,GAAG,CAACb,YAAYc;IAExC,IAAIN,QAAQJ,IAAI,IAAI,MAAMK,OAAOI,GAAG,CAACZ,YAAYe,OAAOR,QAAQJ,IAAI;IACpE,IAAII,QAAQH,QAAQ,IAAI,MAAM;QAC5BI,OAAOI,GAAG,CAACX,iBAAiBc,OAAOR,QAAQH,QAAQ;IACrD;IAEA,OAAOI;AACT;AAEA,8EAA8E,GAC9E,SAASQ,oBACPR,MAAuB,EACvBS,IAAY,EACZC,QAAgB;IAEhB,MAAMC,MAAMX,OAAOY,GAAG,CAACH;IACvB,IAAIE,QAAQ,QAAQA,IAAIE,IAAI,OAAO,IAAI,OAAOH;IAE9C,MAAMI,QAAQC,OAAOJ;IACrB,IAAI,CAACI,OAAOC,SAAS,CAACF,UAAUA,QAAQ,GAAG;QACzC,MAAM,IAAI9B,kBACR,CAAC,CAAC,EAAEyB,KAAK,4BAA4B,CAAC,EACtCQ,WACA;YAAE,CAACR,KAAK,EAAEE;QAAI;IAElB;IACA,OAAOG;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASI,uBACdC,iBAA6C,EAC7CnB,MAAuB,EACvBoB,WAAyC,CAAC,CAAC;IAE3C,MAAM,EAAEzB,IAAI,EAAEC,QAAQ,EAAEC,WAAW,EAAE,GAAG,aAAKH,UAAa0B;IAE1D,MAAMC,aAAarB,OAAOY,GAAG,CAACtB;IAC9B,MAAMa,YAAYkB,CAAAA,8BAAAA,WAAYR,IAAI,MAC9B;QAAC5B,gBAAgBkC,mBAAmBjC,UAAUmC;KAAa,GAC3DJ;IAEJ,MAAMX,UAAUlB,UAAU+B,mBAAmBnB,OAAOY,GAAG,CAACrB;IAExD,MAAMQ,UAAsC;QAC1CJ,MAAMa,oBAAoBR,QAAQR,YAAYG;QAC9CC,UAAU0B,KAAKC,GAAG,CAChBf,oBAAoBR,QAAQP,iBAAiBG,WAC7CC;IAEJ;IAEA,IAAIM,WAAWJ,QAAQI,SAAS,GAAGA;IACnC,IAAIG,SAASP,QAAQO,OAAO,GAAGA;IAE/B,OAAOP;AACT"}

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

@@ -0,0 +1,35 @@
+import { type RsqlOperator } from './rsql-operators.js';
+/**
+ * A parsed filter before coercion: identical to an {@link EntityFilter} except
+ * every argument is still the raw string the URL carried. Re-typing needs the
+ * entity's metadata, which this parser deliberately does not have — see
+ * `coerce-rsql`.
+ */
+export type RawFilter = {
+    property: string;
+    operator: RsqlOperator;
+    value?: string;
+    values?: string[];
+    start?: string;
+    end?: string;
+};
+export type RawFilterGroup = {
+    operator: 'and' | 'or';
+    values: Array<RawFilter | RawFilterGroup>;
+};
+/**
+ * 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 declare function parseRsql(expression: string): RawFilterGroup;
+/** Narrows a raw node to a comparison. */
+export declare function isRawFilter(node: RawFilter | RawFilterGroup): node is RawFilter;
+//# sourceMappingURL=parse-rsql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-rsql.d.ts","sourceRoot":"","sources":["../../src/rsql/parse-rsql.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,KAAK,CAAC,SAAS,GAAG,cAAc,CAAC,CAAC;CAC3C,CAAC;AA4NF;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAiB5D;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,GAAG,cAAc,GAC/B,IAAI,IAAI,SAAS,CAEnB"}