@ahoo-wang/wow-client 9.2.0-rc.0

package/dist/error/queryErrorCodes.d.ts

@@ -0,0 +1,199 @@
+/**
+ * The codes a rejected query carries as `BindingError.code`: which rule the
+ * request broke, stable where the human text (`errorMsg`) is not.
+ *
+ * Mirrors `QueryErrorCodes` in
+ * `wow-api/src/main/kotlin/me/ahoo/wow/api/query/QueryErrorCodes.kt`, which the
+ * server also publishes as the `BindingError.code` enum of its OpenAPI
+ * document. The list is open: Wow adds codes and never renames or reuses one,
+ * so a client treats a code it does not know as a generic rejection and shows
+ * `errorMsg`. {@link QueryErrorCode} admits those codes too.
+ *
+ * Three groups, which `BindingError.name` locates differently:
+ * - decoding the request body (`errorCode` `IllegalArgument`): `name` is the
+ *   JSON path of the offending value, such as `filter.state` or `metrics[0]`,
+ *   or `body` for the body as a whole;
+ * - the entry's budget and gates (`errorCode` `IllegalArgument`): `name` is
+ *   the part of the request the rule bounds, such as `limit` or `filter`;
+ * - admission against the query model (`errorCode` `QuerySchemaValidation`):
+ *   `name` is the absolute logical field path, such as `state.items.sku`, or
+ *   `''` when the rule is about the model rather than one field.
+ *
+ * Budget and gate rejections carry a code from Wow 9.2 on; an older server
+ * answers them with text alone (`HTTP list query limit[...] must be …`). A
+ * failure of the server itself is no rejection: it answers HTTP 500
+ * `InternalServerError` without a binding error.
+ */
+export declare const QueryErrorCodes: Readonly<{
+    /** The body is not valid JSON. */
+    readonly INVALID_JSON: "INVALID_JSON";
+    /** The body is JSON but not an object. */
+    readonly BODY_NOT_OBJECT: "BODY_NOT_OBJECT";
+    /** The body is empty. */
+    readonly EMPTY_BODY: "EMPTY_BODY";
+    /** The body has a property the query type does not declare. */
+    readonly UNKNOWN_PROPERTY: "UNKNOWN_PROPERTY";
+    /** An `op`, metric or other type discriminator names no known type. */
+    readonly UNKNOWN_TYPE: "UNKNOWN_TYPE";
+    /** An enum value is not one the server knows. */
+    readonly UNKNOWN_VALUE: "UNKNOWN_VALUE";
+    /** A value is missing or has the wrong JSON type. */
+    readonly INVALID_VALUE: "INVALID_VALUE";
+    /** Any other request rule; the message names it. */
+    readonly INVALID_REQUEST: "INVALID_REQUEST";
+    /** A cursor sort names a field twice; `path` is the repeated field. */
+    readonly CURSOR_SORT_DUPLICATE: "CURSOR_SORT_DUPLICATE";
+    /** A cursor sort has too many fields once the identity tie-breaker is appended. */
+    readonly CURSOR_SORT_TOO_MANY: "CURSOR_SORT_TOO_MANY";
+    /**
+     * The cursor token was not issued for this model and effective sort, or
+     * does not decode; `path` is `cursor`. Start again from the first page.
+     */
+    readonly INVALID_CURSOR: "INVALID_CURSOR";
+    /**
+     * The entry's budget: a list or aggregation `limit`, a page's index, size,
+     * window or offset, or a cursor page's `size` is out of range; `path` names
+     * which (`limit`, `pagination.size`, `size`, …).
+     */
+    readonly SIZE_OUT_OF_RANGE: "SIZE_OUT_OF_RANGE";
+    /**
+     * The entry's budget: the filter or `having` has too many nodes or values;
+     * `path` is `filter` or `having`.
+     */
+    readonly FILTER_TOO_LARGE: "FILTER_TOO_LARGE";
+    /**
+     * The entry does not allow expensive operators, and the query uses one: an
+     * operator, an element expansion, a metric sort, an arithmetic or
+     * expression group, a date part, a dense fill or FIRST / LAST; `path` names
+     * the part (`filter`, `elements`, `sort`, `metrics`, `groupBy`).
+     */
+    readonly EXPENSIVE_OPERATOR_DISABLED: "EXPENSIVE_OPERATOR_DISABLED";
+    /**
+     * A counting query (count, or a paged query's total) would match every
+     * record, which the entry refuses; `path` is `filter`.
+     */
+    readonly COUNT_REQUIRES_FILTER: "COUNT_REQUIRES_FILTER";
+    /**
+     * A `having` or metric sort the storage evaluates after grouping read more
+     * groups than the server allows; `path` is `body`. It may end a stream
+     * partway through.
+     */
+    readonly RESIDUAL_GROUPS_EXCEEDED: "RESIDUAL_GROUPS_EXCEEDED";
+    /**
+     * An in-process query named no entry where one is required. Never
+     * answered over HTTP; listed so the mirror stays complete.
+     */
+    readonly EXPLICIT_ENTRY_REQUIRED: "EXPLICIT_ENTRY_REQUIRED";
+    /** The model has no such logical field. */
+    readonly UNKNOWN_FIELD: "UNKNOWN_FIELD";
+    /** The field does not offer the capability the query uses (sort, range, …). */
+    readonly UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY";
+    /** The field is an element field and must be queried inside its element scope. */
+    readonly ELEMENT_SCOPE_REQUIRED: "ELEMENT_SCOPE_REQUIRED";
+    /** A filter value falls outside the field's declared domain. */
+    readonly VALUE_MISMATCH: "VALUE_MISMATCH";
+    /** The field is not a known collection (for example under `isEmpty`). */
+    readonly NOT_COLLECTION: "NOT_COLLECTION";
+    /** The field is not a single string. */
+    readonly NOT_SINGLE_STRING: "NOT_SINGLE_STRING";
+    /** The model does not support search. */
+    readonly MODEL_SEARCH_UNSUPPORTED: "MODEL_SEARCH_UNSUPPORTED";
+    /** The field cannot be used for a cursor. */
+    readonly CURSOR_NOT_ALLOWED: "CURSOR_NOT_ALLOWED";
+    /** The field is protected and cannot be aggregated. */
+    readonly PROTECTED_AGGREGATION: "PROTECTED_AGGREGATION";
+    /**
+     * The field is protected and cannot be filtered or sorted: its descriptor
+     * says `sensitivity.comparable: false`. A search that names it is refused
+     * the same way.
+     */
+    readonly PROTECTED_COMPARISON: "PROTECTED_COMPARISON";
+    /** A terms group's `missingKey` needs a single-valued string field. */
+    readonly MISSING_KEY_REQUIRES_STRING: "MISSING_KEY_REQUIRES_STRING";
+    /** `ANY` needs a single value. */
+    readonly ANY_REQUIRES_SINGLE_VALUE: "ANY_REQUIRES_SINGLE_VALUE";
+    /** The storage cannot deliver a complete projection; select fields explicitly. */
+    readonly INCOMPLETE_PROJECTION: "INCOMPLETE_PROJECTION";
+    /** A metric filter uses a search filter. */
+    readonly METRIC_FILTER_SEARCH: "METRIC_FILTER_SEARCH";
+    /** A metric filter uses `ELEMENT_MATCH`. */
+    readonly METRIC_FILTER_ELEMENT_MATCH: "METRIC_FILTER_ELEMENT_MATCH";
+    /** A metric filter names an array field; it must be scalar. */
+    readonly METRIC_FILTER_ARRAY_FIELD: "METRIC_FILTER_ARRAY_FIELD";
+    /** The field cannot be projected. */
+    readonly NOT_PROJECTABLE: "NOT_PROJECTABLE";
+    /** An event projection that keeps payloads must keep their `bodyType`. */
+    readonly EVENT_PROJECTION_TYPE_REQUIRED: "EVENT_PROJECTION_TYPE_REQUIRED";
+    /** A relative-time filter needs a field with a known temporal representation. */
+    readonly TEMPORAL_REPRESENTATION_REQUIRED: "TEMPORAL_REPRESENTATION_REQUIRED";
+    /** A relative-time filter's zone, pattern or unit conflicts with the field's definition. */
+    readonly TEMPORAL_CONFIGURATION_CONFLICT: "TEMPORAL_CONFIGURATION_CONFLICT";
+    /**
+     * A sort names two array fields on independent arrays, which the storage
+     * cannot order by together; `path` is the second of them. The descriptor
+     * lists such fields under a `PARALLEL_ARRAY_SORT` constraint.
+     */
+    readonly PARALLEL_ARRAY_SORT: "PARALLEL_ARRAY_SORT";
+    /**
+     * An `EQ` or `NE` compares the field to an array, which the storage cannot
+     * do: it takes only a scalar operand. The descriptor says so with an
+     * `ARRAY_EQUALITY` constraint.
+     */
+    readonly ARRAY_EQUALITY: "ARRAY_EQUALITY";
+    /**
+     * A `FIRST` or `LAST` metric names a field that may hold several values;
+     * it needs a single-valued one (`aggregate.firstLast` in the descriptor).
+     */
+    readonly FIRST_LAST_REQUIRES_SINGLE_VALUE: "FIRST_LAST_REQUIRES_SINGLE_VALUE";
+    /**
+     * A `FIRST` or `LAST` metric names no `orderBy` where there is no event
+     * time to order by, such as inside an element or on a model whose
+     * descriptor has no `analysis.firstLastOrderBy`; `path` is its field.
+     */
+    readonly FIRST_LAST_REQUIRES_ORDER_BY: "FIRST_LAST_REQUIRES_ORDER_BY";
+    /**
+     * A date group or date difference names a field that stores neither a
+     * date nor an epoch (a formatted string, say), so it cannot be aggregated
+     * by time.
+     */
+    readonly TEMPORAL_AGGREGATION_UNSUPPORTED: "TEMPORAL_AGGREGATION_UNSUPPORTED";
+    /** The sort has more fields than the protocol allows; `path` is `''`. */
+    readonly SORT_TOO_MANY: "SORT_TOO_MANY";
+    /** Two sort fields name the same stored field; `path` is the second. */
+    readonly SORT_FIELD_DUPLICATE: "SORT_FIELD_DUPLICATE";
+    /**
+     * An identity filter or a cursor on a model that defines no record
+     * identity; `path` is `''`.
+     */
+    readonly IDENTITY_UNDEFINED: "IDENTITY_UNDEFINED";
+    /**
+     * The storage does not support the feature the query uses, or its native
+     * query language cannot express it (a MongoDB PHRASE search with a quote,
+     * say); `path` is the field, or `''`.
+     */
+    readonly STORAGE_UNSUPPORTED: "STORAGE_UNSUPPORTED";
+}>;
+/** One of the codes this package knows; see {@link QueryErrorCodes}. */
+export type KnownQueryErrorCode = (typeof QueryErrorCodes)[keyof typeof QueryErrorCodes];
+/**
+ * The code of a rejected query: one this package knows, which editors
+ * complete, or one a newer server added.
+ */
+export type QueryErrorCode = KnownQueryErrorCode | (string & {});
+/**
+ * Why the server rejected a request, read from its first binding error that
+ * carries a code: which rule failed, where, and the server's words.
+ */
+export interface QueryViolation {
+    /** Which rule failed; switch on it against {@link QueryErrorCodes}. */
+    code: QueryErrorCode;
+    /**
+     * Where: the JSON path of the offending value for a decoding error
+     * (`filter.state`, `metrics[0]`, `body`), the absolute logical field path
+     * for an admission error (`state.items.sku`), or `''` when the rule is about
+     * the model rather than a field.
+     */
+    path: string;
+    /** The server's words, the same as the error's `errorMsg`. */
+    message: string;
+}

package/dist/error/queryErrorCodes.es.js

@@ -0,0 +1,53 @@
+//#region src/error/queryErrorCodes.ts
+var e = Object.freeze({
+	INVALID_JSON: "INVALID_JSON",
+	BODY_NOT_OBJECT: "BODY_NOT_OBJECT",
+	EMPTY_BODY: "EMPTY_BODY",
+	UNKNOWN_PROPERTY: "UNKNOWN_PROPERTY",
+	UNKNOWN_TYPE: "UNKNOWN_TYPE",
+	UNKNOWN_VALUE: "UNKNOWN_VALUE",
+	INVALID_VALUE: "INVALID_VALUE",
+	INVALID_REQUEST: "INVALID_REQUEST",
+	CURSOR_SORT_DUPLICATE: "CURSOR_SORT_DUPLICATE",
+	CURSOR_SORT_TOO_MANY: "CURSOR_SORT_TOO_MANY",
+	INVALID_CURSOR: "INVALID_CURSOR",
+	SIZE_OUT_OF_RANGE: "SIZE_OUT_OF_RANGE",
+	FILTER_TOO_LARGE: "FILTER_TOO_LARGE",
+	EXPENSIVE_OPERATOR_DISABLED: "EXPENSIVE_OPERATOR_DISABLED",
+	COUNT_REQUIRES_FILTER: "COUNT_REQUIRES_FILTER",
+	RESIDUAL_GROUPS_EXCEEDED: "RESIDUAL_GROUPS_EXCEEDED",
+	EXPLICIT_ENTRY_REQUIRED: "EXPLICIT_ENTRY_REQUIRED",
+	UNKNOWN_FIELD: "UNKNOWN_FIELD",
+	UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY",
+	ELEMENT_SCOPE_REQUIRED: "ELEMENT_SCOPE_REQUIRED",
+	VALUE_MISMATCH: "VALUE_MISMATCH",
+	NOT_COLLECTION: "NOT_COLLECTION",
+	NOT_SINGLE_STRING: "NOT_SINGLE_STRING",
+	MODEL_SEARCH_UNSUPPORTED: "MODEL_SEARCH_UNSUPPORTED",
+	CURSOR_NOT_ALLOWED: "CURSOR_NOT_ALLOWED",
+	PROTECTED_AGGREGATION: "PROTECTED_AGGREGATION",
+	PROTECTED_COMPARISON: "PROTECTED_COMPARISON",
+	MISSING_KEY_REQUIRES_STRING: "MISSING_KEY_REQUIRES_STRING",
+	ANY_REQUIRES_SINGLE_VALUE: "ANY_REQUIRES_SINGLE_VALUE",
+	INCOMPLETE_PROJECTION: "INCOMPLETE_PROJECTION",
+	METRIC_FILTER_SEARCH: "METRIC_FILTER_SEARCH",
+	METRIC_FILTER_ELEMENT_MATCH: "METRIC_FILTER_ELEMENT_MATCH",
+	METRIC_FILTER_ARRAY_FIELD: "METRIC_FILTER_ARRAY_FIELD",
+	NOT_PROJECTABLE: "NOT_PROJECTABLE",
+	EVENT_PROJECTION_TYPE_REQUIRED: "EVENT_PROJECTION_TYPE_REQUIRED",
+	TEMPORAL_REPRESENTATION_REQUIRED: "TEMPORAL_REPRESENTATION_REQUIRED",
+	TEMPORAL_CONFIGURATION_CONFLICT: "TEMPORAL_CONFIGURATION_CONFLICT",
+	PARALLEL_ARRAY_SORT: "PARALLEL_ARRAY_SORT",
+	ARRAY_EQUALITY: "ARRAY_EQUALITY",
+	FIRST_LAST_REQUIRES_SINGLE_VALUE: "FIRST_LAST_REQUIRES_SINGLE_VALUE",
+	FIRST_LAST_REQUIRES_ORDER_BY: "FIRST_LAST_REQUIRES_ORDER_BY",
+	TEMPORAL_AGGREGATION_UNSUPPORTED: "TEMPORAL_AGGREGATION_UNSUPPORTED",
+	SORT_TOO_MANY: "SORT_TOO_MANY",
+	SORT_FIELD_DUPLICATE: "SORT_FIELD_DUPLICATE",
+	IDENTITY_UNDEFINED: "IDENTITY_UNDEFINED",
+	STORAGE_UNSUPPORTED: "STORAGE_UNSUPPORTED"
+});
+//#endregion
+export { e as QueryErrorCodes };
+
+//# sourceMappingURL=queryErrorCodes.es.js.map

package/dist/error/queryErrorCodes.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryErrorCodes.es.js","names":["QueryErrorCodes"],"sources":["../../src/error/queryErrorCodes.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The codes a rejected query carries as `BindingError.code`: which rule the\n * request broke, stable where the human text (`errorMsg`) is not.\n *\n * Mirrors `QueryErrorCodes` in\n * `wow-api/src/main/kotlin/me/ahoo/wow/api/query/QueryErrorCodes.kt`, which the\n * server also publishes as the `BindingError.code` enum of its OpenAPI\n * document. The list is open: Wow adds codes and never renames or reuses one,\n * so a client treats a code it does not know as a generic rejection and shows\n * `errorMsg`. {@link QueryErrorCode} admits those codes too.\n *\n * Three groups, which `BindingError.name` locates differently:\n * - decoding the request body (`errorCode` `IllegalArgument`): `name` is the\n *   JSON path of the offending value, such as `filter.state` or `metrics[0]`,\n *   or `body` for the body as a whole;\n * - the entry's budget and gates (`errorCode` `IllegalArgument`): `name` is\n *   the part of the request the rule bounds, such as `limit` or `filter`;\n * - admission against the query model (`errorCode` `QuerySchemaValidation`):\n *   `name` is the absolute logical field path, such as `state.items.sku`, or\n *   `''` when the rule is about the model rather than one field.\n *\n * Budget and gate rejections carry a code from Wow 9.2 on; an older server\n * answers them with text alone (`HTTP list query limit[...] must be …`). A\n * failure of the server itself is no rejection: it answers HTTP 500\n * `InternalServerError` without a binding error.\n */\nexport const QueryErrorCodes = Object.freeze({\n  /** The body is not valid JSON. */\n  INVALID_JSON: 'INVALID_JSON',\n  /** The body is JSON but not an object. */\n  BODY_NOT_OBJECT: 'BODY_NOT_OBJECT',\n  /** The body is empty. */\n  EMPTY_BODY: 'EMPTY_BODY',\n  /** The body has a property the query type does not declare. */\n  UNKNOWN_PROPERTY: 'UNKNOWN_PROPERTY',\n  /** An `op`, metric or other type discriminator names no known type. */\n  UNKNOWN_TYPE: 'UNKNOWN_TYPE',\n  /** An enum value is not one the server knows. */\n  UNKNOWN_VALUE: 'UNKNOWN_VALUE',\n  /** A value is missing or has the wrong JSON type. */\n  INVALID_VALUE: 'INVALID_VALUE',\n  /** Any other request rule; the message names it. */\n  INVALID_REQUEST: 'INVALID_REQUEST',\n  /** A cursor sort names a field twice; `path` is the repeated field. */\n  CURSOR_SORT_DUPLICATE: 'CURSOR_SORT_DUPLICATE',\n  /** A cursor sort has too many fields once the identity tie-breaker is appended. */\n  CURSOR_SORT_TOO_MANY: 'CURSOR_SORT_TOO_MANY',\n  /**\n   * The cursor token was not issued for this model and effective sort, or\n   * does not decode; `path` is `cursor`. Start again from the first page.\n   */\n  INVALID_CURSOR: 'INVALID_CURSOR',\n  /**\n   * The entry's budget: a list or aggregation `limit`, a page's index, size,\n   * window or offset, or a cursor page's `size` is out of range; `path` names\n   * which (`limit`, `pagination.size`, `size`, …).\n   */\n  SIZE_OUT_OF_RANGE: 'SIZE_OUT_OF_RANGE',\n  /**\n   * The entry's budget: the filter or `having` has too many nodes or values;\n   * `path` is `filter` or `having`.\n   */\n  FILTER_TOO_LARGE: 'FILTER_TOO_LARGE',\n  /**\n   * The entry does not allow expensive operators, and the query uses one: an\n   * operator, an element expansion, a metric sort, an arithmetic or\n   * expression group, a date part, a dense fill or FIRST / LAST; `path` names\n   * the part (`filter`, `elements`, `sort`, `metrics`, `groupBy`).\n   */\n  EXPENSIVE_OPERATOR_DISABLED: 'EXPENSIVE_OPERATOR_DISABLED',\n  /**\n   * A counting query (count, or a paged query's total) would match every\n   * record, which the entry refuses; `path` is `filter`.\n   */\n  COUNT_REQUIRES_FILTER: 'COUNT_REQUIRES_FILTER',\n  /**\n   * A `having` or metric sort the storage evaluates after grouping read more\n   * groups than the server allows; `path` is `body`. It may end a stream\n   * partway through.\n   */\n  RESIDUAL_GROUPS_EXCEEDED: 'RESIDUAL_GROUPS_EXCEEDED',\n  /**\n   * An in-process query named no entry where one is required. Never\n   * answered over HTTP; listed so the mirror stays complete.\n   */\n  EXPLICIT_ENTRY_REQUIRED: 'EXPLICIT_ENTRY_REQUIRED',\n  /** The model has no such logical field. */\n  UNKNOWN_FIELD: 'UNKNOWN_FIELD',\n  /** The field does not offer the capability the query uses (sort, range, …). */\n  UNSUPPORTED_CAPABILITY: 'UNSUPPORTED_CAPABILITY',\n  /** The field is an element field and must be queried inside its element scope. */\n  ELEMENT_SCOPE_REQUIRED: 'ELEMENT_SCOPE_REQUIRED',\n  /** A filter value falls outside the field's declared domain. */\n  VALUE_MISMATCH: 'VALUE_MISMATCH',\n  /** The field is not a known collection (for example under `isEmpty`). */\n  NOT_COLLECTION: 'NOT_COLLECTION',\n  /** The field is not a single string. */\n  NOT_SINGLE_STRING: 'NOT_SINGLE_STRING',\n  /** The model does not support search. */\n  MODEL_SEARCH_UNSUPPORTED: 'MODEL_SEARCH_UNSUPPORTED',\n  /** The field cannot be used for a cursor. */\n  CURSOR_NOT_ALLOWED: 'CURSOR_NOT_ALLOWED',\n  /** The field is protected and cannot be aggregated. */\n  PROTECTED_AGGREGATION: 'PROTECTED_AGGREGATION',\n  /**\n   * The field is protected and cannot be filtered or sorted: its descriptor\n   * says `sensitivity.comparable: false`. A search that names it is refused\n   * the same way.\n   */\n  PROTECTED_COMPARISON: 'PROTECTED_COMPARISON',\n  /** A terms group's `missingKey` needs a single-valued string field. */\n  MISSING_KEY_REQUIRES_STRING: 'MISSING_KEY_REQUIRES_STRING',\n  /** `ANY` needs a single value. */\n  ANY_REQUIRES_SINGLE_VALUE: 'ANY_REQUIRES_SINGLE_VALUE',\n  /** The storage cannot deliver a complete projection; select fields explicitly. */\n  INCOMPLETE_PROJECTION: 'INCOMPLETE_PROJECTION',\n  /** A metric filter uses a search filter. */\n  METRIC_FILTER_SEARCH: 'METRIC_FILTER_SEARCH',\n  /** A metric filter uses `ELEMENT_MATCH`. */\n  METRIC_FILTER_ELEMENT_MATCH: 'METRIC_FILTER_ELEMENT_MATCH',\n  /** A metric filter names an array field; it must be scalar. */\n  METRIC_FILTER_ARRAY_FIELD: 'METRIC_FILTER_ARRAY_FIELD',\n  /** The field cannot be projected. */\n  NOT_PROJECTABLE: 'NOT_PROJECTABLE',\n  /** An event projection that keeps payloads must keep their `bodyType`. */\n  EVENT_PROJECTION_TYPE_REQUIRED: 'EVENT_PROJECTION_TYPE_REQUIRED',\n  /** A relative-time filter needs a field with a known temporal representation. */\n  TEMPORAL_REPRESENTATION_REQUIRED: 'TEMPORAL_REPRESENTATION_REQUIRED',\n  /** A relative-time filter's zone, pattern or unit conflicts with the field's definition. */\n  TEMPORAL_CONFIGURATION_CONFLICT: 'TEMPORAL_CONFIGURATION_CONFLICT',\n  /**\n   * A sort names two array fields on independent arrays, which the storage\n   * cannot order by together; `path` is the second of them. The descriptor\n   * lists such fields under a `PARALLEL_ARRAY_SORT` constraint.\n   */\n  PARALLEL_ARRAY_SORT: 'PARALLEL_ARRAY_SORT',\n  /**\n   * An `EQ` or `NE` compares the field to an array, which the storage cannot\n   * do: it takes only a scalar operand. The descriptor says so with an\n   * `ARRAY_EQUALITY` constraint.\n   */\n  ARRAY_EQUALITY: 'ARRAY_EQUALITY',\n  /**\n   * A `FIRST` or `LAST` metric names a field that may hold several values;\n   * it needs a single-valued one (`aggregate.firstLast` in the descriptor).\n   */\n  FIRST_LAST_REQUIRES_SINGLE_VALUE: 'FIRST_LAST_REQUIRES_SINGLE_VALUE',\n  /**\n   * A `FIRST` or `LAST` metric names no `orderBy` where there is no event\n   * time to order by, such as inside an element or on a model whose\n   * descriptor has no `analysis.firstLastOrderBy`; `path` is its field.\n   */\n  FIRST_LAST_REQUIRES_ORDER_BY: 'FIRST_LAST_REQUIRES_ORDER_BY',\n  /**\n   * A date group or date difference names a field that stores neither a\n   * date nor an epoch (a formatted string, say), so it cannot be aggregated\n   * by time.\n   */\n  TEMPORAL_AGGREGATION_UNSUPPORTED: 'TEMPORAL_AGGREGATION_UNSUPPORTED',\n  /** The sort has more fields than the protocol allows; `path` is `''`. */\n  SORT_TOO_MANY: 'SORT_TOO_MANY',\n  /** Two sort fields name the same stored field; `path` is the second. */\n  SORT_FIELD_DUPLICATE: 'SORT_FIELD_DUPLICATE',\n  /**\n   * An identity filter or a cursor on a model that defines no record\n   * identity; `path` is `''`.\n   */\n  IDENTITY_UNDEFINED: 'IDENTITY_UNDEFINED',\n  /**\n   * The storage does not support the feature the query uses, or its native\n   * query language cannot express it (a MongoDB PHRASE search with a quote,\n   * say); `path` is the field, or `''`.\n   */\n  STORAGE_UNSUPPORTED: 'STORAGE_UNSUPPORTED',\n} as const);\n\n/** One of the codes this package knows; see {@link QueryErrorCodes}. */\nexport type KnownQueryErrorCode =\n  (typeof QueryErrorCodes)[keyof typeof QueryErrorCodes];\n\n/**\n * The code of a rejected query: one this package knows, which editors\n * complete, or one a newer server added.\n */\nexport type QueryErrorCode = KnownQueryErrorCode | (string & {});\n\n/**\n * Why the server rejected a request, read from its first binding error that\n * carries a code: which rule failed, where, and the server's words.\n */\nexport interface QueryViolation {\n  /** Which rule failed; switch on it against {@link QueryErrorCodes}. */\n  code: QueryErrorCode;\n  /**\n   * Where: the JSON path of the offending value for a decoding error\n   * (`filter.state`, `metrics[0]`, `body`), the absolute logical field path\n   * for an admission error (`state.items.sku`), or `''` when the rule is about\n   * the model rather than a field.\n   */\n  path: string;\n  /** The server's words, the same as the error's `errorMsg`. */\n  message: string;\n}\n"],"mappings":";AAuCA,IAAaA,IAAkB,OAAO,OAAO;CAE3C,cAAc;CAEd,iBAAiB;CAEjB,YAAY;CAEZ,kBAAkB;CAElB,cAAc;CAEd,eAAe;CAEf,eAAe;CAEf,iBAAiB;CAEjB,uBAAuB;CAEvB,sBAAsB;CAKtB,gBAAgB;CAMhB,mBAAmB;CAKnB,kBAAkB;CAOlB,6BAA6B;CAK7B,uBAAuB;CAMvB,0BAA0B;CAK1B,yBAAyB;CAEzB,eAAe;CAEf,wBAAwB;CAExB,wBAAwB;CAExB,gBAAgB;CAEhB,gBAAgB;CAEhB,mBAAmB;CAEnB,0BAA0B;CAE1B,oBAAoB;CAEpB,uBAAuB;CAMvB,sBAAsB;CAEtB,6BAA6B;CAE7B,2BAA2B;CAE3B,uBAAuB;CAEvB,sBAAsB;CAEtB,6BAA6B;CAE7B,2BAA2B;CAE3B,iBAAiB;CAEjB,gCAAgC;CAEhC,kCAAkC;CAElC,iCAAiC;CAMjC,qBAAqB;CAMrB,gBAAgB;CAKhB,kCAAkC;CAMlC,8BAA8B;CAM9B,kCAAkC;CAElC,eAAe;CAEf,sBAAsB;CAKtB,oBAAoB;CAMpB,qBAAqB;AACvB,CAAU"}

package/dist/error/wowError.cjs

@@ -0,0 +1,2 @@
+const e=require("./errorInfo.cjs"),t=require("./headers.cjs");var n=/\blist query limit\[0\] must be between /;function r({errorCode:t,errorMsg:r,bindingErrors:i}){return(t===e.ErrorCodes.ILLEGAL_ARGUMENT||(i??[]).some(e=>e?.code===`SIZE_OUT_OF_RANGE`))&&r!==void 0&&n.test(r)?` The query has no limit: omitting it needs Wow 9.1.5 or later, so pass one, for example listQuery({ limit: 100 }).`:``}var i=class extends Error{constructor(e,t={}){super((e.errorMsg?`[${e.errorCode}] ${e.errorMsg}`:e.errorCode)+r(e)),this.name=`WowError`,t.cause!==void 0&&(this.cause=t.cause),this.errorCode=e.errorCode,this.errorMsg=e.errorMsg??``,this.bindingErrors=e.bindingErrors??[],t.status!==void 0&&(this.status=t.status);for(let{name:e,msg:t,code:n}of this.bindingErrors)if(typeof n==`string`){this.violation={code:n,path:e??``,message:t??this.errorMsg};break}}};function a(e){if(typeof e!=`object`||!e)return!1;let{errorCode:t,errorMsg:n}=e;return typeof t==`string`&&(n===void 0||typeof n==`string`)}async function o(e){let n=e.headers.get(t.WowHeaders.ERROR_CODE),r;try{r=await e.clone().json()}catch{}if(a(r))return r;if(n)return{errorCode:n,errorMsg:e.statusText}}async function s(e){if(e instanceof i)return e;if(typeof e!=`object`||!e)return;let{exchange:t,cause:n}=e;if(n instanceof i)return n;let r=t?.response;if(!r||r.ok)return;let a=await o(r);return a?new i(a,{status:r.status,cause:e}):void 0}exports.WowError=i,exports.isErrorInfo=a,exports.toWowError=s;
+//# sourceMappingURL=wowError.cjs.map

package/dist/error/wowError.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wowError.cjs","names":["ErrorCodes","WowHeaders","require_errorInfo","require_headers","MISSING_LIST_LIMIT","hintFor","errorCode","bindingErrors","error","errorMsg","WowError","errorInfo","options","code","name","msg","isErrorInfo","value","readErrorInfo","header","response","body","toWowError","cause","exchange"],"sources":["../../src/error/wowError.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ErrorCodes,\n  type BindingError,\n  type ErrorCode,\n  type ErrorInfo,\n} from './errorInfo.js';\nimport { WowHeaders } from './headers.js';\nimport type { QueryViolation } from './queryErrorCodes.js';\n\n/** Where a {@link WowError} came from, besides its `ErrorInfo`. */\nexport interface WowErrorOptions {\n  /** The HTTP status of the response that carried the error, if any. */\n  status?: number;\n  /** The error this one explains: the fetcher's, or the stream's. */\n  cause?: unknown;\n}\n\n/**\n * Wow 8.11 to 9.1.3 answer a list query without a `limit` with this message;\n * 9.1.5 applies its default list size instead.\n */\nconst MISSING_LIST_LIMIT = /\\blist query limit\\[0\\] must be between /;\n\n/**\n * What to do about an error whose cause the client knows, appended to the\n * message only: `errorMsg` stays the server's own words.\n */\nfunction hintFor({ errorCode, errorMsg, bindingErrors }: ErrorInfo): string {\n  // An older server says it with `IllegalArgument` alone; one that codes its\n  // budget rejections (Wow 9.2) says `SIZE_OUT_OF_RANGE` too. The words are\n  // what tell a missing limit from a limit out of range.\n  const outOfRange =\n    errorCode === ErrorCodes.ILLEGAL_ARGUMENT ||\n    (bindingErrors ?? []).some(\n      // `QueryErrorCodes.SIZE_OUT_OF_RANGE`, spelled out to keep this module\n      // free of the catalogue.\n      error => error?.code === 'SIZE_OUT_OF_RANGE',\n    );\n  if (\n    outOfRange &&\n    errorMsg !== undefined &&\n    MISSING_LIST_LIMIT.test(errorMsg)\n  ) {\n    return (\n      ' The query has no limit: omitting it needs Wow 9.1.5 or later, so ' +\n      'pass one, for example listQuery({ limit: 100 }).'\n    );\n  }\n  return '';\n}\n\n/**\n * An error the Wow server answered with.\n *\n * Its `message` is `[errorCode] errorMsg`. When the client knows what causes\n * an error it adds what to do to the message, never to `errorMsg`: a list\n * query without a `limit`, which Wow 8.11 to 9.1.3 refuse with\n * `IllegalArgument`, says to pass one.\n *\n * It carries the server's `ErrorInfo` — `errorCode`, `errorMsg`,\n * `bindingErrors` — and, when a response carried it, the HTTP status. Switch\n * on `errorCode` against {@link ErrorCodes}; a rejected query also says which\n * rule it broke and where as {@link WowError.violation}.\n *\n * Two paths produce one:\n * - a server-sent event stream of this package (query streams and\n *   `sendAndWaitStream`) errors with a `WowError` when the server sends an\n *   error event in the middle of it; a `for await` over the stream throws it;\n * - {@link toWowError} turns what a failed request threw into one.\n *\n * @example\n * ```typescript\n * async function findState(id: string) {\n *   try {\n *     return await snapshotClient.getStateById(id);\n *   } catch (error) {\n *     const wowError = await toWowError(error);\n *     if (wowError?.errorCode === ErrorCodes.NOT_FOUND) return undefined;\n *     throw wowError ?? error;\n *   }\n * }\n * ```\n */\nexport class WowError extends Error implements ErrorInfo {\n  override readonly name = 'WowError';\n  readonly errorCode: ErrorCode;\n  readonly errorMsg: string;\n  readonly bindingErrors: BindingError[];\n  /** The HTTP status of the response that carried the error, if any. */\n  readonly status?: number;\n  /** The error this one explains: the fetcher's, or the stream's. */\n  readonly cause?: unknown;\n  /**\n   * Which rule a rejected request broke, and where, read from the first of\n   * `bindingErrors` that carries a `code`; `undefined` when none does.\n   *\n   * Wow answers a query it rejects while decoding (`IllegalArgument`) or\n   * admitting it against the query model (`QuerySchemaValidation`) with one\n   * such binding error, whose message is `errorMsg`. Switch on its `code`\n   * against {@link QueryErrorCodes}, and fall back to `errorMsg` for a code\n   * this package does not know: the list only grows. From Wow 9.2 the\n   * entry's budget and gates say their rule too (`SIZE_OUT_OF_RANGE`,\n   * `EXPENSIVE_OPERATOR_DISABLED`, …); an older server answers them with\n   * text alone (`HTTP list query limit[...]`). A command's validation error\n   * carries no code, and neither does a failure of the server itself (HTTP\n   * 500 `InternalServerError`).\n   *\n   * @example\n   * ```typescript\n   * async function fieldInError(error: unknown): Promise<string | undefined> {\n   *   const violation = (await toWowError(error))?.violation;\n   *   if (violation?.code === QueryErrorCodes.UNKNOWN_FIELD) {\n   *     return violation.path; // e.g. 'state.items.sku'\n   *   }\n   *   return undefined;\n   * }\n   * ```\n   */\n  readonly violation?: QueryViolation;\n\n  constructor(errorInfo: ErrorInfo, options: WowErrorOptions = {}) {\n    super(\n      (errorInfo.errorMsg\n        ? `[${errorInfo.errorCode}] ${errorInfo.errorMsg}`\n        : errorInfo.errorCode) + hintFor(errorInfo),\n    );\n    if (options.cause !== undefined) this.cause = options.cause;\n    this.errorCode = errorInfo.errorCode;\n    this.errorMsg = errorInfo.errorMsg ?? '';\n    this.bindingErrors = errorInfo.bindingErrors ?? [];\n    if (options.status !== undefined) this.status = options.status;\n    for (const { name, msg, code } of this.bindingErrors) {\n      if (typeof code !== 'string') continue;\n      this.violation = {\n        code,\n        path: name ?? '',\n        message: msg ?? this.errorMsg,\n      };\n      break;\n    }\n  }\n}\n\n/**\n * Whether a value has the shape of the server's `ErrorInfo`: an object with a\n * string `errorCode`, and `errorMsg` a string when present.\n */\nexport function isErrorInfo(value: unknown): value is ErrorInfo {\n  if (typeof value !== 'object' || value === null) return false;\n  const { errorCode, errorMsg } = value as Partial<Record<string, unknown>>;\n  return (\n    typeof errorCode === 'string' &&\n    (errorMsg === undefined || typeof errorMsg === 'string')\n  );\n}\n\n/** The part of a fetcher error this module reads, without importing fetcher. */\ninterface ExchangeLike {\n  exchange?: { response?: Response };\n  cause?: unknown;\n}\n\nasync function readErrorInfo(\n  response: Response,\n): Promise<ErrorInfo | undefined> {\n  const header = response.headers.get(WowHeaders.ERROR_CODE);\n  let body: unknown;\n  try {\n    body = await response.clone().json();\n  } catch {\n    // Not JSON, or already read: the header is all there is.\n  }\n  if (isErrorInfo(body)) return body;\n  if (header) return { errorCode: header, errorMsg: response.statusText };\n  return undefined;\n}\n\n/**\n * Turns what a failed request threw into a {@link WowError}, or `undefined`\n * when it is not an error the Wow server answered with (a network failure, a\n * timeout, an abort, a proxy's own error page).\n *\n * It reads, in order: a `WowError` itself or as the `cause`; otherwise the\n * failed response of a fetcher error (`ExchangeError`,\n * `HttpStatusValidationError`), whose body is the server's `ErrorInfo`, or\n * failing that its `Wow-Error-Code` header. The response is cloned, so its\n * body stays readable.\n *\n * It is asynchronous because the error body has to be read; a thrown fetcher\n * error has not read it.\n */\nexport async function toWowError(\n  error: unknown,\n): Promise<WowError | undefined> {\n  if (error instanceof WowError) return error;\n  if (typeof error !== 'object' || error === null) return undefined;\n  const { exchange, cause } = error as ExchangeLike;\n  if (cause instanceof WowError) return cause;\n  const response = exchange?.response;\n  if (!response || response.ok) return undefined;\n  const errorInfo = await readErrorInfo(response);\n  return errorInfo\n    ? new WowError(errorInfo, { status: response.status, cause: error })\n    : undefined;\n}\n"],"mappings":"8DAkCA,IAAMI,EAAqB,2CAM3B,SAASC,EAAQ,CAAE,YAAW,WAAU,iBAAoC,CAqB1E,OAhBEC,IAAcN,EAAAA,WAAW,mBACxBO,GAAiB,CAAC,EAAA,CAAG,KAGpB,GAASC,GAAO,OAAS,mBAC3B,IAGAC,IAAa,IAAA,IACbL,EAAmB,KAAKK,CAAQ,EAG9B,qHAIG,EACT,CAkCA,IAAaC,EAAb,cAA8B,KAA2B,CAqCvD,YAAY,EAAsB,EAA2B,CAAC,EAAG,CAC/D,OACGC,EAAU,SACP,IAAIA,EAAU,UAAU,IAAIA,EAAU,WACtCA,EAAU,WAAaN,EAAQM,CAAS,CAC9C,EAzCuB,KAAA,KAAA,WA0CnBC,EAAQ,QAAU,IAAA,KAAW,KAAK,MAAQA,EAAQ,OACtD,KAAK,UAAYD,EAAU,UAC3B,KAAK,SAAWA,EAAU,UAAY,GACtC,KAAK,cAAgBA,EAAU,eAAiB,CAAC,EAC7CC,EAAQ,SAAW,IAAA,KAAW,KAAK,OAASA,EAAQ,QACxD,IAAK,GAAM,CAAE,OAAM,MAAK,UAAU,KAAK,cACrC,GAAI,OAAOC,GAAS,SACpB,MAAK,UAAY,CACf,OACA,KAAMC,GAAQ,GACd,QAASC,GAAO,KAAK,QACvB,EACA,KADA,CAGJ,CACF,EAMA,SAAgBC,EAAY,EAAoC,CAC9D,GAAI,OAAOC,GAAU,WAAYA,EAAgB,MAAO,GACxD,GAAM,CAAE,YAAW,YAAaA,EAChC,OACE,OAAOX,GAAc,WACpBG,IAAa,IAAA,IAAa,OAAOA,GAAa,SAEnD,CAQA,eAAeS,EACb,EACgC,CAChC,IAAMC,EAASC,EAAS,QAAQ,IAAInB,EAAAA,WAAW,UAAU,EACrDoB,EACJ,GAAI,CACF,EAAO,MAAMD,EAAS,MAAM,CAAC,CAAC,KAAK,CACrC,MAAQ,CAER,CACA,GAAIJ,EAAYK,CAAI,EAAG,OAAOA,EAC9B,GAAIF,EAAQ,MAAO,CAAE,UAAWA,EAAQ,SAAUC,EAAS,UAAW,CAExE,CAgBA,eAAsBE,EACpB,EAC+B,CAC/B,GAAId,aAAiBE,EAAU,OAAOF,EACtC,GAAI,OAAOA,GAAU,WAAYA,EAAgB,OACjD,GAAM,CAAE,WAAU,SAAUA,EAC5B,GAAIe,aAAiBb,EAAU,OAAOa,EACtC,IAAMH,EAAWI,GAAU,SAC3B,GAAI,CAACJ,GAAYA,EAAS,GAAI,OAC9B,IAAMT,EAAY,MAAMO,EAAcE,CAAQ,EAC9C,OAAOT,EACH,IAAID,EAASC,EAAW,CAAE,OAAQS,EAAS,OAAQ,MAAOZ,CAAM,CAAC,EACjE,IAAA,EACN"}

package/dist/error/wowError.d.cts

@@ -0,0 +1,99 @@
+import { BindingError, ErrorCode, ErrorInfo } from './errorInfo.cjs';
+import { QueryViolation } from './queryErrorCodes.cjs';
+/** Where a {@link WowError} came from, besides its `ErrorInfo`. */
+export interface WowErrorOptions {
+    /** The HTTP status of the response that carried the error, if any. */
+    status?: number;
+    /** The error this one explains: the fetcher's, or the stream's. */
+    cause?: unknown;
+}
+/**
+ * An error the Wow server answered with.
+ *
+ * Its `message` is `[errorCode] errorMsg`. When the client knows what causes
+ * an error it adds what to do to the message, never to `errorMsg`: a list
+ * query without a `limit`, which Wow 8.11 to 9.1.3 refuse with
+ * `IllegalArgument`, says to pass one.
+ *
+ * It carries the server's `ErrorInfo` — `errorCode`, `errorMsg`,
+ * `bindingErrors` — and, when a response carried it, the HTTP status. Switch
+ * on `errorCode` against {@link ErrorCodes}; a rejected query also says which
+ * rule it broke and where as {@link WowError.violation}.
+ *
+ * Two paths produce one:
+ * - a server-sent event stream of this package (query streams and
+ *   `sendAndWaitStream`) errors with a `WowError` when the server sends an
+ *   error event in the middle of it; a `for await` over the stream throws it;
+ * - {@link toWowError} turns what a failed request threw into one.
+ *
+ * @example
+ * ```typescript
+ * async function findState(id: string) {
+ *   try {
+ *     return await snapshotClient.getStateById(id);
+ *   } catch (error) {
+ *     const wowError = await toWowError(error);
+ *     if (wowError?.errorCode === ErrorCodes.NOT_FOUND) return undefined;
+ *     throw wowError ?? error;
+ *   }
+ * }
+ * ```
+ */
+export declare class WowError extends Error implements ErrorInfo {
+    readonly name = "WowError";
+    readonly errorCode: ErrorCode;
+    readonly errorMsg: string;
+    readonly bindingErrors: BindingError[];
+    /** The HTTP status of the response that carried the error, if any. */
+    readonly status?: number;
+    /** The error this one explains: the fetcher's, or the stream's. */
+    readonly cause?: unknown;
+    /**
+     * Which rule a rejected request broke, and where, read from the first of
+     * `bindingErrors` that carries a `code`; `undefined` when none does.
+     *
+     * Wow answers a query it rejects while decoding (`IllegalArgument`) or
+     * admitting it against the query model (`QuerySchemaValidation`) with one
+     * such binding error, whose message is `errorMsg`. Switch on its `code`
+     * against {@link QueryErrorCodes}, and fall back to `errorMsg` for a code
+     * this package does not know: the list only grows. From Wow 9.2 the
+     * entry's budget and gates say their rule too (`SIZE_OUT_OF_RANGE`,
+     * `EXPENSIVE_OPERATOR_DISABLED`, …); an older server answers them with
+     * text alone (`HTTP list query limit[...]`). A command's validation error
+     * carries no code, and neither does a failure of the server itself (HTTP
+     * 500 `InternalServerError`).
+     *
+     * @example
+     * ```typescript
+     * async function fieldInError(error: unknown): Promise<string | undefined> {
+     *   const violation = (await toWowError(error))?.violation;
+     *   if (violation?.code === QueryErrorCodes.UNKNOWN_FIELD) {
+     *     return violation.path; // e.g. 'state.items.sku'
+     *   }
+     *   return undefined;
+     * }
+     * ```
+     */
+    readonly violation?: QueryViolation;
+    constructor(errorInfo: ErrorInfo, options?: WowErrorOptions);
+}
+/**
+ * Whether a value has the shape of the server's `ErrorInfo`: an object with a
+ * string `errorCode`, and `errorMsg` a string when present.
+ */
+export declare function isErrorInfo(value: unknown): value is ErrorInfo;
+/**
+ * Turns what a failed request threw into a {@link WowError}, or `undefined`
+ * when it is not an error the Wow server answered with (a network failure, a
+ * timeout, an abort, a proxy's own error page).
+ *
+ * It reads, in order: a `WowError` itself or as the `cause`; otherwise the
+ * failed response of a fetcher error (`ExchangeError`,
+ * `HttpStatusValidationError`), whose body is the server's `ErrorInfo`, or
+ * failing that its `Wow-Error-Code` header. The response is cloned, so its
+ * body stays readable.
+ *
+ * It is asynchronous because the error body has to be read; a thrown fetcher
+ * error has not read it.
+ */
+export declare function toWowError(error: unknown): Promise<WowError | undefined>;

package/dist/error/wowError.d.ts

@@ -0,0 +1,99 @@
+import { BindingError, ErrorCode, ErrorInfo } from './errorInfo.js';
+import { QueryViolation } from './queryErrorCodes.js';
+/** Where a {@link WowError} came from, besides its `ErrorInfo`. */
+export interface WowErrorOptions {
+    /** The HTTP status of the response that carried the error, if any. */
+    status?: number;
+    /** The error this one explains: the fetcher's, or the stream's. */
+    cause?: unknown;
+}
+/**
+ * An error the Wow server answered with.
+ *
+ * Its `message` is `[errorCode] errorMsg`. When the client knows what causes
+ * an error it adds what to do to the message, never to `errorMsg`: a list
+ * query without a `limit`, which Wow 8.11 to 9.1.3 refuse with
+ * `IllegalArgument`, says to pass one.
+ *
+ * It carries the server's `ErrorInfo` — `errorCode`, `errorMsg`,
+ * `bindingErrors` — and, when a response carried it, the HTTP status. Switch
+ * on `errorCode` against {@link ErrorCodes}; a rejected query also says which
+ * rule it broke and where as {@link WowError.violation}.
+ *
+ * Two paths produce one:
+ * - a server-sent event stream of this package (query streams and
+ *   `sendAndWaitStream`) errors with a `WowError` when the server sends an
+ *   error event in the middle of it; a `for await` over the stream throws it;
+ * - {@link toWowError} turns what a failed request threw into one.
+ *
+ * @example
+ * ```typescript
+ * async function findState(id: string) {
+ *   try {
+ *     return await snapshotClient.getStateById(id);
+ *   } catch (error) {
+ *     const wowError = await toWowError(error);
+ *     if (wowError?.errorCode === ErrorCodes.NOT_FOUND) return undefined;
+ *     throw wowError ?? error;
+ *   }
+ * }
+ * ```
+ */
+export declare class WowError extends Error implements ErrorInfo {
+    readonly name = "WowError";
+    readonly errorCode: ErrorCode;
+    readonly errorMsg: string;
+    readonly bindingErrors: BindingError[];
+    /** The HTTP status of the response that carried the error, if any. */
+    readonly status?: number;
+    /** The error this one explains: the fetcher's, or the stream's. */
+    readonly cause?: unknown;
+    /**
+     * Which rule a rejected request broke, and where, read from the first of
+     * `bindingErrors` that carries a `code`; `undefined` when none does.
+     *
+     * Wow answers a query it rejects while decoding (`IllegalArgument`) or
+     * admitting it against the query model (`QuerySchemaValidation`) with one
+     * such binding error, whose message is `errorMsg`. Switch on its `code`
+     * against {@link QueryErrorCodes}, and fall back to `errorMsg` for a code
+     * this package does not know: the list only grows. From Wow 9.2 the
+     * entry's budget and gates say their rule too (`SIZE_OUT_OF_RANGE`,
+     * `EXPENSIVE_OPERATOR_DISABLED`, …); an older server answers them with
+     * text alone (`HTTP list query limit[...]`). A command's validation error
+     * carries no code, and neither does a failure of the server itself (HTTP
+     * 500 `InternalServerError`).
+     *
+     * @example
+     * ```typescript
+     * async function fieldInError(error: unknown): Promise<string | undefined> {
+     *   const violation = (await toWowError(error))?.violation;
+     *   if (violation?.code === QueryErrorCodes.UNKNOWN_FIELD) {
+     *     return violation.path; // e.g. 'state.items.sku'
+     *   }
+     *   return undefined;
+     * }
+     * ```
+     */
+    readonly violation?: QueryViolation;
+    constructor(errorInfo: ErrorInfo, options?: WowErrorOptions);
+}
+/**
+ * Whether a value has the shape of the server's `ErrorInfo`: an object with a
+ * string `errorCode`, and `errorMsg` a string when present.
+ */
+export declare function isErrorInfo(value: unknown): value is ErrorInfo;
+/**
+ * Turns what a failed request threw into a {@link WowError}, or `undefined`
+ * when it is not an error the Wow server answered with (a network failure, a
+ * timeout, an abort, a proxy's own error page).
+ *
+ * It reads, in order: a `WowError` itself or as the `cause`; otherwise the
+ * failed response of a fetcher error (`ExchangeError`,
+ * `HttpStatusValidationError`), whose body is the server's `ErrorInfo`, or
+ * failing that its `Wow-Error-Code` header. The response is cloned, so its
+ * body stays readable.
+ *
+ * It is asynchronous because the error body has to be read; a thrown fetcher
+ * error has not read it.
+ */
+export declare function toWowError(error: unknown): Promise<WowError | undefined>;

package/dist/error/wowError.es.js

@@ -0,0 +1,53 @@
+import { ErrorCodes as e } from "./errorInfo.es.js";
+import { WowHeaders as t } from "./headers.es.js";
+//#region src/error/wowError.ts
+var n = /\blist query limit\[0\] must be between /;
+function r({ errorCode: t, errorMsg: r, bindingErrors: i }) {
+	return (t === e.ILLEGAL_ARGUMENT || (i ?? []).some((e) => e?.code === "SIZE_OUT_OF_RANGE")) && r !== void 0 && n.test(r) ? " The query has no limit: omitting it needs Wow 9.1.5 or later, so pass one, for example listQuery({ limit: 100 })." : "";
+}
+var i = class extends Error {
+	constructor(e, t = {}) {
+		super((e.errorMsg ? `[${e.errorCode}] ${e.errorMsg}` : e.errorCode) + r(e)), this.name = "WowError", t.cause !== void 0 && (this.cause = t.cause), this.errorCode = e.errorCode, this.errorMsg = e.errorMsg ?? "", this.bindingErrors = e.bindingErrors ?? [], t.status !== void 0 && (this.status = t.status);
+		for (let { name: e, msg: t, code: n } of this.bindingErrors) if (typeof n == "string") {
+			this.violation = {
+				code: n,
+				path: e ?? "",
+				message: t ?? this.errorMsg
+			};
+			break;
+		}
+	}
+};
+function a(e) {
+	if (typeof e != "object" || !e) return !1;
+	let { errorCode: t, errorMsg: n } = e;
+	return typeof t == "string" && (n === void 0 || typeof n == "string");
+}
+async function o(e) {
+	let n = e.headers.get(t.ERROR_CODE), r;
+	try {
+		r = await e.clone().json();
+	} catch {}
+	if (a(r)) return r;
+	if (n) return {
+		errorCode: n,
+		errorMsg: e.statusText
+	};
+}
+async function s(e) {
+	if (e instanceof i) return e;
+	if (typeof e != "object" || !e) return;
+	let { exchange: t, cause: n } = e;
+	if (n instanceof i) return n;
+	let r = t?.response;
+	if (!r || r.ok) return;
+	let a = await o(r);
+	return a ? new i(a, {
+		status: r.status,
+		cause: e
+	}) : void 0;
+}
+//#endregion
+export { i as WowError, a as isErrorInfo, s as toWowError };
+
+//# sourceMappingURL=wowError.es.js.map

package/dist/error/wowError.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wowError.es.js","names":["MISSING_LIST_LIMIT","hintFor","errorCode","ErrorCodes","bindingErrors","error","errorMsg","WowError","errorInfo","options","code","name","msg","isErrorInfo","value","readErrorInfo","header","response","WowHeaders","body","toWowError","cause","exchange"],"sources":["../../src/error/wowError.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ErrorCodes,\n  type BindingError,\n  type ErrorCode,\n  type ErrorInfo,\n} from './errorInfo.js';\nimport { WowHeaders } from './headers.js';\nimport type { QueryViolation } from './queryErrorCodes.js';\n\n/** Where a {@link WowError} came from, besides its `ErrorInfo`. */\nexport interface WowErrorOptions {\n  /** The HTTP status of the response that carried the error, if any. */\n  status?: number;\n  /** The error this one explains: the fetcher's, or the stream's. */\n  cause?: unknown;\n}\n\n/**\n * Wow 8.11 to 9.1.3 answer a list query without a `limit` with this message;\n * 9.1.5 applies its default list size instead.\n */\nconst MISSING_LIST_LIMIT = /\\blist query limit\\[0\\] must be between /;\n\n/**\n * What to do about an error whose cause the client knows, appended to the\n * message only: `errorMsg` stays the server's own words.\n */\nfunction hintFor({ errorCode, errorMsg, bindingErrors }: ErrorInfo): string {\n  // An older server says it with `IllegalArgument` alone; one that codes its\n  // budget rejections (Wow 9.2) says `SIZE_OUT_OF_RANGE` too. The words are\n  // what tell a missing limit from a limit out of range.\n  const outOfRange =\n    errorCode === ErrorCodes.ILLEGAL_ARGUMENT ||\n    (bindingErrors ?? []).some(\n      // `QueryErrorCodes.SIZE_OUT_OF_RANGE`, spelled out to keep this module\n      // free of the catalogue.\n      error => error?.code === 'SIZE_OUT_OF_RANGE',\n    );\n  if (\n    outOfRange &&\n    errorMsg !== undefined &&\n    MISSING_LIST_LIMIT.test(errorMsg)\n  ) {\n    return (\n      ' The query has no limit: omitting it needs Wow 9.1.5 or later, so ' +\n      'pass one, for example listQuery({ limit: 100 }).'\n    );\n  }\n  return '';\n}\n\n/**\n * An error the Wow server answered with.\n *\n * Its `message` is `[errorCode] errorMsg`. When the client knows what causes\n * an error it adds what to do to the message, never to `errorMsg`: a list\n * query without a `limit`, which Wow 8.11 to 9.1.3 refuse with\n * `IllegalArgument`, says to pass one.\n *\n * It carries the server's `ErrorInfo` — `errorCode`, `errorMsg`,\n * `bindingErrors` — and, when a response carried it, the HTTP status. Switch\n * on `errorCode` against {@link ErrorCodes}; a rejected query also says which\n * rule it broke and where as {@link WowError.violation}.\n *\n * Two paths produce one:\n * - a server-sent event stream of this package (query streams and\n *   `sendAndWaitStream`) errors with a `WowError` when the server sends an\n *   error event in the middle of it; a `for await` over the stream throws it;\n * - {@link toWowError} turns what a failed request threw into one.\n *\n * @example\n * ```typescript\n * async function findState(id: string) {\n *   try {\n *     return await snapshotClient.getStateById(id);\n *   } catch (error) {\n *     const wowError = await toWowError(error);\n *     if (wowError?.errorCode === ErrorCodes.NOT_FOUND) return undefined;\n *     throw wowError ?? error;\n *   }\n * }\n * ```\n */\nexport class WowError extends Error implements ErrorInfo {\n  override readonly name = 'WowError';\n  readonly errorCode: ErrorCode;\n  readonly errorMsg: string;\n  readonly bindingErrors: BindingError[];\n  /** The HTTP status of the response that carried the error, if any. */\n  readonly status?: number;\n  /** The error this one explains: the fetcher's, or the stream's. */\n  readonly cause?: unknown;\n  /**\n   * Which rule a rejected request broke, and where, read from the first of\n   * `bindingErrors` that carries a `code`; `undefined` when none does.\n   *\n   * Wow answers a query it rejects while decoding (`IllegalArgument`) or\n   * admitting it against the query model (`QuerySchemaValidation`) with one\n   * such binding error, whose message is `errorMsg`. Switch on its `code`\n   * against {@link QueryErrorCodes}, and fall back to `errorMsg` for a code\n   * this package does not know: the list only grows. From Wow 9.2 the\n   * entry's budget and gates say their rule too (`SIZE_OUT_OF_RANGE`,\n   * `EXPENSIVE_OPERATOR_DISABLED`, …); an older server answers them with\n   * text alone (`HTTP list query limit[...]`). A command's validation error\n   * carries no code, and neither does a failure of the server itself (HTTP\n   * 500 `InternalServerError`).\n   *\n   * @example\n   * ```typescript\n   * async function fieldInError(error: unknown): Promise<string | undefined> {\n   *   const violation = (await toWowError(error))?.violation;\n   *   if (violation?.code === QueryErrorCodes.UNKNOWN_FIELD) {\n   *     return violation.path; // e.g. 'state.items.sku'\n   *   }\n   *   return undefined;\n   * }\n   * ```\n   */\n  readonly violation?: QueryViolation;\n\n  constructor(errorInfo: ErrorInfo, options: WowErrorOptions = {}) {\n    super(\n      (errorInfo.errorMsg\n        ? `[${errorInfo.errorCode}] ${errorInfo.errorMsg}`\n        : errorInfo.errorCode) + hintFor(errorInfo),\n    );\n    if (options.cause !== undefined) this.cause = options.cause;\n    this.errorCode = errorInfo.errorCode;\n    this.errorMsg = errorInfo.errorMsg ?? '';\n    this.bindingErrors = errorInfo.bindingErrors ?? [];\n    if (options.status !== undefined) this.status = options.status;\n    for (const { name, msg, code } of this.bindingErrors) {\n      if (typeof code !== 'string') continue;\n      this.violation = {\n        code,\n        path: name ?? '',\n        message: msg ?? this.errorMsg,\n      };\n      break;\n    }\n  }\n}\n\n/**\n * Whether a value has the shape of the server's `ErrorInfo`: an object with a\n * string `errorCode`, and `errorMsg` a string when present.\n */\nexport function isErrorInfo(value: unknown): value is ErrorInfo {\n  if (typeof value !== 'object' || value === null) return false;\n  const { errorCode, errorMsg } = value as Partial<Record<string, unknown>>;\n  return (\n    typeof errorCode === 'string' &&\n    (errorMsg === undefined || typeof errorMsg === 'string')\n  );\n}\n\n/** The part of a fetcher error this module reads, without importing fetcher. */\ninterface ExchangeLike {\n  exchange?: { response?: Response };\n  cause?: unknown;\n}\n\nasync function readErrorInfo(\n  response: Response,\n): Promise<ErrorInfo | undefined> {\n  const header = response.headers.get(WowHeaders.ERROR_CODE);\n  let body: unknown;\n  try {\n    body = await response.clone().json();\n  } catch {\n    // Not JSON, or already read: the header is all there is.\n  }\n  if (isErrorInfo(body)) return body;\n  if (header) return { errorCode: header, errorMsg: response.statusText };\n  return undefined;\n}\n\n/**\n * Turns what a failed request threw into a {@link WowError}, or `undefined`\n * when it is not an error the Wow server answered with (a network failure, a\n * timeout, an abort, a proxy's own error page).\n *\n * It reads, in order: a `WowError` itself or as the `cause`; otherwise the\n * failed response of a fetcher error (`ExchangeError`,\n * `HttpStatusValidationError`), whose body is the server's `ErrorInfo`, or\n * failing that its `Wow-Error-Code` header. The response is cloned, so its\n * body stays readable.\n *\n * It is asynchronous because the error body has to be read; a thrown fetcher\n * error has not read it.\n */\nexport async function toWowError(\n  error: unknown,\n): Promise<WowError | undefined> {\n  if (error instanceof WowError) return error;\n  if (typeof error !== 'object' || error === null) return undefined;\n  const { exchange, cause } = error as ExchangeLike;\n  if (cause instanceof WowError) return cause;\n  const response = exchange?.response;\n  if (!response || response.ok) return undefined;\n  const errorInfo = await readErrorInfo(response);\n  return errorInfo\n    ? new WowError(errorInfo, { status: response.status, cause: error })\n    : undefined;\n}\n"],"mappings":";;;AAkCA,IAAMA,IAAqB;AAM3B,SAASC,EAAQ,EAAE,cAAW,aAAU,oBAAoC;CAqB1E,QAhBEC,MAAcC,EAAW,qBACxBC,KAAiB,CAAC,EAAA,CAAG,MAGpB,MAASC,GAAO,SAAS,mBAC3B,MAGAC,MAAa,KAAA,KACbN,EAAmB,KAAKM,CAAQ,IAG9B,uHAIG;AACT;AAkCA,IAAaC,IAAb,cAA8B,MAA2B;CAqCvD,YAAY,GAAsB,IAA2B,CAAC,GAAG;EAU/D,AATA,OACGC,EAAU,WACP,IAAIA,EAAU,UAAU,IAAIA,EAAU,aACtCA,EAAU,aAAaP,EAAQO,CAAS,CAC9C,GAzCuB,KAAA,OAAA,YA0CnBC,EAAQ,UAAU,KAAA,MAAW,KAAK,QAAQA,EAAQ,QACtD,KAAK,YAAYD,EAAU,WAC3B,KAAK,WAAWA,EAAU,YAAY,IACtC,KAAK,gBAAgBA,EAAU,iBAAiB,CAAC,GAC7CC,EAAQ,WAAW,KAAA,MAAW,KAAK,SAASA,EAAQ;EACxD,KAAK,IAAM,EAAE,SAAM,QAAK,aAAU,KAAK,eACrC,IAAI,OAAOC,KAAS,UACpB;QAAK,YAAY;IACf;IACA,MAAMC,KAAQ;IACd,SAASC,KAAO,KAAK;GACvB;GACA;EADA;CAGJ;AACF;AAMA,SAAgBC,EAAY,GAAoC;CAC9D,IAAI,OAAOC,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAM,EAAE,cAAW,gBAAaA;CAChC,OACE,OAAOZ,KAAc,aACpBI,MAAa,KAAA,KAAa,OAAOA,KAAa;AAEnD;AAQA,eAAeS,EACb,GACgC;CAChC,IAAMC,IAASC,EAAS,QAAQ,IAAIC,EAAW,UAAU,GACrDC;CACJ,IAAI;EACF,IAAO,MAAMF,EAAS,MAAM,CAAC,CAAC,KAAK;CACrC,QAAQ,CAER;CACA,IAAIJ,EAAYM,CAAI,GAAG,OAAOA;CAC9B,IAAIH,GAAQ,OAAO;EAAE,WAAWA;EAAQ,UAAUC,EAAS;CAAW;AAExE;AAgBA,eAAsBG,EACpB,GAC+B;CAC/B,IAAIf,aAAiBE,GAAU,OAAOF;CACtC,IAAI,OAAOA,KAAU,aAAYA,GAAgB;CACjD,IAAM,EAAE,aAAU,aAAUA;CAC5B,IAAIgB,aAAiBd,GAAU,OAAOc;CACtC,IAAMJ,IAAWK,GAAU;CAC3B,IAAI,CAACL,KAAYA,EAAS,IAAI;CAC9B,IAAMT,IAAY,MAAMO,EAAcE,CAAQ;CAC9C,OAAOT,IACH,IAAID,EAASC,GAAW;EAAE,QAAQS,EAAS;EAAQ,OAAOZ;CAAM,CAAC,IACjE,KAAA;AACN"}

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./dsl/filter/operator.cjs"),t=require("./dsl/aggregation/types.cjs"),n=require("./dsl/deletionState.cjs"),r=require("./dsl/filter/builders.cjs"),i=require("./dsl/sort.cjs"),a=require("./dsl/aggregation/builders.cjs"),o=require("./dsl/projection.cjs"),s=require("./dsl/pagination.cjs"),c=require("./dsl/cursorQuery.cjs"),l=require("./dsl/queryable.cjs"),u=require("./dsl/descriptor.cjs"),d=require("./error/errorInfo.cjs"),f=require("./error/headers.cjs"),p=require("./error/wowError.cjs"),m=require("./model/command.cjs"),h=require("./transport/endpoints.cjs"),g=require("./client/command/commandClient.cjs"),_=require("./client/command/commandHeaders.cjs"),v=require("./model/abac.cjs"),y=require("./model/bi.cjs"),b=require("./model/function.cjs"),x=require("./client/command/commandRequest.cjs"),S=require("./client/metadata/wowMetadataClient.cjs"),C=require("./client/query/event/domainEventStream.cjs"),w=require("./client/query/event/eventStreamQueryClient.cjs"),T=require("./client/query/snapshot/snapshot.cjs"),E=require("./client/query/snapshot/snapshotQueryClient.cjs"),D=require("./client/query/state/loadStateAggregateClient.cjs"),O=require("./client/query/state/loadOwnerStateAggregateClient.cjs"),k=require("./client/query/descriptor/queryDescriptorClient.cjs"),A=require("./client/query/factory.cjs"),j=require("./client/routing.cjs"),M=require("./error/queryErrorCodes.cjs");exports.AGGREGATION_LIMITS=t.AGGREGATION_LIMITS,exports.AggregationDatePart=t.AggregationDatePart,exports.AggregationDateUnit=t.AggregationDateUnit,exports.AggregationExpressionOperator=t.AggregationExpressionOperator,exports.AggregationExpressionType=t.AggregationExpressionType,exports.AggregationFunction=t.AggregationFunction,exports.AggregationGroupType=t.AggregationGroupType,exports.AggregationMetricType=t.AggregationMetricType,exports.COMMAND_STREAM_ENDPOINT=h.COMMAND_STREAM_ENDPOINT,Object.defineProperty(exports,"CommandClient",{enumerable:!0,get:function(){return g.CommandClient}}),exports.CommandHeaders=_.CommandHeaders,exports.CommandStage=m.CommandStage,exports.ComparisonOperator=t.ComparisonOperator,exports.DEFAULT_CURSOR_SIZE=c.DEFAULT_CURSOR_SIZE,exports.DEFAULT_PAGINATION=s.DEFAULT_PAGINATION,exports.DateDiffUnit=t.DateDiffUnit,exports.DeletionState=n.DeletionState,exports.DerivedExpressionType=t.DerivedExpressionType,exports.DomainEventStreamMetadataFields=C.DomainEventStreamMetadataFields,exports.EMPTY_ABAC_TAGS=v.EMPTY_ABAC_TAGS,exports.ErrorCodes=d.ErrorCodes,Object.defineProperty(exports,"EventStreamQueryClient",{enumerable:!0,get:function(){return w.EventStreamQueryClient}}),exports.FilterOperator=e.FilterOperator,exports.FunctionKind=b.FunctionKind,exports.HavingExpressionType=t.HavingExpressionType,Object.defineProperty(exports,"LoadOwnerStateAggregateClient",{enumerable:!0,get:function(){return O.LoadOwnerStateAggregateClient}}),Object.defineProperty(exports,"LoadStateAggregateClient",{enumerable:!0,get:function(){return D.LoadStateAggregateClient}}),exports.MAX_CURSOR_SIZE=c.MAX_CURSOR_SIZE,exports.MAX_CURSOR_SORT_FIELDS=c.MAX_CURSOR_SORT_FIELDS,exports.MessageHeaderSqlType=y.MessageHeaderSqlType,exports.PagingMode=u.PagingMode,exports.QUERY_STREAM_ENDPOINT=h.QUERY_STREAM_ENDPOINT,exports.QueryClientFactory=A.QueryClientFactory,exports.QueryConstraintTypes=u.QueryConstraintTypes,exports.QueryDescriptorClient=k.QueryDescriptorClient,exports.QueryErrorCodes=M.QueryErrorCodes,exports.QueryFieldRoles=u.QueryFieldRoles,exports.QueryModels=u.QueryModels,exports.QueryValueKind=u.QueryValueKind,exports.QueryValueTypes=u.QueryValueTypes,exports.RecoverableType=d.RecoverableType,exports.ResourceAttributionPathSpec=j.ResourceAttributionPathSpec,exports.SearchMode=e.SearchMode,exports.SensitivityLevel=u.SensitivityLevel,exports.SnapshotMetadataFields=T.SnapshotMetadataFields,Object.defineProperty(exports,"SnapshotQueryClient",{enumerable:!0,get:function(){return E.SnapshotQueryClient}}),exports.SortDirection=i.SortDirection,exports.StringComparison=e.StringComparison,exports.TimeUnit=e.TimeUnit,exports.WILDCARD_ABAC_TAG_VALUES=v.WILDCARD_ABAC_TAG_VALUES,exports.WowError=p.WowError,exports.WowHeaders=f.WowHeaders,Object.defineProperty(exports,"WowMetadataClient",{enumerable:!0,get:function(){return S.WowMetadataClient}}),exports.aggregation=a.aggregation,exports.asc=i.asc,exports.commandHeaders=x.commandHeaders,exports.cursorQuery=c.cursorQuery,exports.desc=i.desc,exports.filter=r.filter,exports.isErrorInfo=p.isErrorInfo,exports.listQuery=l.listQuery,exports.pagedList=l.pagedList,exports.pagedQuery=l.pagedQuery,exports.pagination=s.pagination,exports.projection=o.projection,exports.singleQuery=l.singleQuery,exports.toWowError=p.toWowError,exports.waitStrategy=x.waitStrategy;

package/dist/index.d.cts

@@ -0,0 +1,17 @@
+export * from './dsl/filter/index.cjs';
+export * from './dsl/aggregation/index.cjs';
+export * from './dsl/sort.cjs';
+export * from './dsl/projection.cjs';
+export * from './dsl/pagination.cjs';
+export * from './dsl/cursorQuery.cjs';
+export * from './dsl/queryable.cjs';
+export * from './dsl/deletionState.cjs';
+export * from './dsl/documents.cjs';
+export * from './dsl/descriptor.cjs';
+export * from './client/command/index.cjs';
+export * from './client/metadata/index.cjs';
+export * from './client/query/index.cjs';
+export * from './client/routing.cjs';
+export * from './transport/index.cjs';
+export * from './model/index.cjs';
+export * from './error/index.cjs';

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from './dsl/filter/index.js';
+export * from './dsl/aggregation/index.js';
+export * from './dsl/sort.js';
+export * from './dsl/projection.js';
+export * from './dsl/pagination.js';
+export * from './dsl/cursorQuery.js';
+export * from './dsl/queryable.js';
+export * from './dsl/deletionState.js';
+export * from './dsl/documents.js';
+export * from './dsl/descriptor.js';
+export * from './client/command/index.js';
+export * from './client/metadata/index.js';
+export * from './client/query/index.js';
+export * from './client/routing.js';
+export * from './transport/index.js';
+export * from './model/index.js';
+export * from './error/index.js';