@aglyn/plugins-commerce 1.0.0-beta.199 → 1.0.0-beta.201

package/src/lib/constants/orders-list-query.js

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { ORDER_CHANNEL_LABELS, ORDER_STATUS_LABELS } from "../model/commerce-orders.js";
+/*
+ * THE ORDERS LIST, ON ITS QUERY (AGL-3321).
+ *
+ * `hosts/{hostId}/orders`, newest first. Every filter the grid's panel offers
+ * and the quick search's word is a predicate on the ONE Firestore query that
+ * pages the list (`planListQuery` through `useListQuery`), over the fields
+ * every writer stamps with `orderListFields` — so page two of a filtered list
+ * is page two of the matches, not page two of the store narrowed afterwards.
+ *
+ * One order: `createdAtMs` descending, the field every writer stamps. Each
+ * filterable field is then ONE `(field, createdAtMs DESC)` composite, and
+ * index merging serves every combination of them; the date range is on that
+ * same field, so it adds none. Eight composites in all, pinned by
+ * `orders-list-query.spec.ts` against `cloud/firebase-firestore.indexes.json`.
+ *
+ * What one query cannot hold is refused by name above the grid
+ * (`ListQueryNotices`, labelled by `listQueryRefusals` from these fields,
+ * headers and options), never matched over the rows it returned: the search,
+ * Customer `contains`, Order `contains` and Product each take the query's one
+ * array clause, so two of them together keep the first and refuse the second.
+ *
+ * A second range (a total, say) would be a new `sorts` entry and one more
+ * composite per filterable field beneath it — eight — plus the range field's
+ * own order; nothing else here moves.
+ */ /** The grid columns, each as the query reads it. */ export const ORDER_LIST_FIELDS = [
+    {
+        // The number as typed, `#1042` or `1042`, by word prefix.
+        column: 'orderLabel',
+        kind: 'text',
+        path: 'number',
+        tokensPath: 'orderLabelTokens',
+        operators: [
+            'contains'
+        ]
+    },
+    {
+        // `is` a whole address; `contains` an address's piece or its domain.
+        column: 'customerEmail',
+        kind: 'text',
+        path: 'customerEmail',
+        lowerPath: 'customerEmailLower',
+        tokensPath: 'customerEmailTokens',
+        operators: [
+            'contains',
+            'equals'
+        ]
+    },
+    {
+        column: 'channelKey',
+        kind: 'exact',
+        path: 'channel',
+        presence: 'always',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'statusKey',
+        kind: 'exact',
+        path: 'status',
+        presence: 'always',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'createdAtMs',
+        kind: 'date',
+        path: 'createdAtMs',
+        storedAs: 'millis',
+        presence: 'always',
+        operators: [
+            'is',
+            'after',
+            'onOrAfter',
+            'before',
+            'onOrBefore'
+        ]
+    },
+    {
+        // Every product in the order, matched whole — ids keep their case.
+        column: 'productIds',
+        kind: 'exact',
+        path: 'productIds',
+        tokensPath: 'productIds',
+        verbatimTokens: true,
+        operators: [
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'disputeKey',
+        kind: 'exact',
+        path: 'disputeKey',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    }
+];
+/** The list's query: its fields, its one order and its search. */ export const ORDER_LIST_QUERY = {
+    fields: ORDER_LIST_FIELDS,
+    sorts: [
+        {
+            path: 'createdAtMs',
+            direction: 'desc',
+            column: 'createdAtMs'
+        }
+    ],
+    search: {
+        tokensPath: 'searchTokens'
+    }
+};
+export const ORDER_LIST_HEADERS = {
+    orderLabel: 'Order',
+    customerEmail: 'Customer',
+    channelKey: 'Channel',
+    statusKey: 'Status',
+    createdAtMs: 'Date',
+    productIds: 'Product',
+    disputeKey: 'Disputes'
+};
+/** The fields picked from choices, which the panel shows as a select. */ export const ORDER_LIST_SELECT_FIELDS = [
+    'channelKey',
+    'statusKey',
+    'productIds',
+    'disputeKey'
+];
+export const ORDER_STATUS_OPTIONS = Object.keys(ORDER_STATUS_LABELS).map((status)=>({
+        value: status,
+        label: ORDER_STATUS_LABELS[status]
+    }));
+export const ORDER_CHANNEL_OPTIONS = Object.keys(ORDER_CHANNEL_LABELS).map((channel)=>({
+        value: channel,
+        label: ORDER_CHANNEL_LABELS[channel]
+    }));
+/*
+ * The dispute badge's tones (`orderDisputeKey`), labelled as the badge
+ * labels them. `lost` is the tone, not the raw dispute status: a dispute
+ * that was WON also closes with money untouched, and listing it as charged
+ * back would tell a merchant they lost a case they won.
+ */ export const ORDER_DISPUTE_OPTIONS = [
+    {
+        value: 'open',
+        label: 'Open dispute'
+    },
+    {
+        value: 'lost',
+        label: 'Charged back'
+    },
+    {
+        value: 'won',
+        label: 'Dispute won'
+    },
+    {
+        value: 'settled',
+        label: 'Dispute closed'
+    }
+];
+/** The clause the open-dispute banner's "Show them" sets. */ export const OPEN_DISPUTE_CLAUSE = {
+    field: 'disputeKey',
+    op: 'equals',
+    value: 'open'
+};
+/**
+ * The Customer clause the CRM's link seeds from `?email=` (AGL-2622).
+ *
+ * A whole address is `is`, served by the lower-cased key, so it finds that
+ * buyer and no one whose address merely begins the same way. Anything else —
+ * a domain, `@acme.com`, a name — is `contains`, a word prefix of the
+ * address, so a domain finds every buyer at a company.
+ */ export function ordersCustomerClause(raw) {
+    const value = raw.trim().replace(/^@+/, '');
+    if (!value) return null;
+    const at = value.indexOf('@');
+    return at > 0 && at < value.length - 1 ? {
+        field: 'customerEmail',
+        op: 'equals',
+        value
+    } : {
+        field: 'customerEmail',
+        op: 'contains',
+        value
+    };
+}
+
+//# sourceMappingURL=orders-list-query.js.map

package/src/lib/constants/orders-list-query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/constants/orders-list-query.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\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 *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\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 type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter'\nimport type {\n  ListFilterClause,\n  ListFilterOption,\n} from '@aglyn/shared-ui-jsx/const/list-grid-filter'\nimport type { ListQueryDeclaration } from '@aglyn/shared-ui-jsx/const/list-query-plan'\nimport {\n  ORDER_CHANNEL_LABELS,\n  ORDER_STATUS_LABELS,\n  type OrderChannel,\n  type OrderStatus,\n} from '../model/commerce-orders'\n\n/*\n * THE ORDERS LIST, ON ITS QUERY (AGL-3321).\n *\n * `hosts/{hostId}/orders`, newest first. Every filter the grid's panel offers\n * and the quick search's word is a predicate on the ONE Firestore query that\n * pages the list (`planListQuery` through `useListQuery`), over the fields\n * every writer stamps with `orderListFields` — so page two of a filtered list\n * is page two of the matches, not page two of the store narrowed afterwards.\n *\n * One order: `createdAtMs` descending, the field every writer stamps. Each\n * filterable field is then ONE `(field, createdAtMs DESC)` composite, and\n * index merging serves every combination of them; the date range is on that\n * same field, so it adds none. Eight composites in all, pinned by\n * `orders-list-query.spec.ts` against `cloud/firebase-firestore.indexes.json`.\n *\n * What one query cannot hold is refused by name above the grid\n * (`ListQueryNotices`, labelled by `listQueryRefusals` from these fields,\n * headers and options), never matched over the rows it returned: the search,\n * Customer `contains`, Order `contains` and Product each take the query's one\n * array clause, so two of them together keep the first and refuse the second.\n *\n * A second range (a total, say) would be a new `sorts` entry and one more\n * composite per filterable field beneath it — eight — plus the range field's\n * own order; nothing else here moves.\n */\n\n/** The grid columns, each as the query reads it. */\nexport const ORDER_LIST_FIELDS: readonly ListFilterField[] = [\n  {\n    // The number as typed, `#1042` or `1042`, by word prefix.\n    column: 'orderLabel',\n    kind: 'text',\n    path: 'number',\n    tokensPath: 'orderLabelTokens',\n    operators: ['contains'],\n  },\n  {\n    // `is` a whole address; `contains` an address's piece or its domain.\n    column: 'customerEmail',\n    kind: 'text',\n    path: 'customerEmail',\n    lowerPath: 'customerEmailLower',\n    tokensPath: 'customerEmailTokens',\n    operators: ['contains', 'equals'],\n  },\n  {\n    column: 'channelKey',\n    kind: 'exact',\n    path: 'channel',\n    presence: 'always',\n    operators: ['equals', 'isAnyOf'],\n  },\n  {\n    column: 'statusKey',\n    kind: 'exact',\n    path: 'status',\n    presence: 'always',\n    operators: ['equals', 'isAnyOf'],\n  },\n  {\n    column: 'createdAtMs',\n    kind: 'date',\n    path: 'createdAtMs',\n    storedAs: 'millis',\n    presence: 'always',\n    operators: ['is', 'after', 'onOrAfter', 'before', 'onOrBefore'],\n  },\n  {\n    // Every product in the order, matched whole — ids keep their case.\n    column: 'productIds',\n    kind: 'exact',\n    path: 'productIds',\n    tokensPath: 'productIds',\n    verbatimTokens: true,\n    operators: ['isAnyOf'],\n  },\n  {\n    column: 'disputeKey',\n    kind: 'exact',\n    path: 'disputeKey',\n    operators: ['equals', 'isAnyOf'],\n  },\n]\n\n/** The list's query: its fields, its one order and its search. */\nexport const ORDER_LIST_QUERY: ListQueryDeclaration = {\n  fields: ORDER_LIST_FIELDS,\n  sorts: [{ path: 'createdAtMs', direction: 'desc', column: 'createdAtMs' }],\n  search: { tokensPath: 'searchTokens' },\n}\n\nexport const ORDER_LIST_HEADERS: Readonly<Record<string, string>> = {\n  orderLabel: 'Order',\n  customerEmail: 'Customer',\n  channelKey: 'Channel',\n  statusKey: 'Status',\n  createdAtMs: 'Date',\n  productIds: 'Product',\n  disputeKey: 'Disputes',\n}\n\n/** The fields picked from choices, which the panel shows as a select. */\nexport const ORDER_LIST_SELECT_FIELDS: readonly string[] = [\n  'channelKey',\n  'statusKey',\n  'productIds',\n  'disputeKey',\n]\n\nexport const ORDER_STATUS_OPTIONS: readonly ListFilterOption[] = (\n  Object.keys(ORDER_STATUS_LABELS) as OrderStatus[]\n).map((status) => ({ value: status, label: ORDER_STATUS_LABELS[status] }))\n\nexport const ORDER_CHANNEL_OPTIONS: readonly ListFilterOption[] = (\n  Object.keys(ORDER_CHANNEL_LABELS) as OrderChannel[]\n).map((channel) => ({ value: channel, label: ORDER_CHANNEL_LABELS[channel] }))\n\n/*\n * The dispute badge's tones (`orderDisputeKey`), labelled as the badge\n * labels them. `lost` is the tone, not the raw dispute status: a dispute\n * that was WON also closes with money untouched, and listing it as charged\n * back would tell a merchant they lost a case they won.\n */\nexport const ORDER_DISPUTE_OPTIONS: readonly ListFilterOption[] = [\n  { value: 'open', label: 'Open dispute' },\n  { value: 'lost', label: 'Charged back' },\n  { value: 'won', label: 'Dispute won' },\n  { value: 'settled', label: 'Dispute closed' },\n]\n\n/** The clause the open-dispute banner's \"Show them\" sets. */\nexport const OPEN_DISPUTE_CLAUSE: ListFilterClause = {\n  field: 'disputeKey',\n  op: 'equals',\n  value: 'open',\n}\n\n/**\n * The Customer clause the CRM's link seeds from `?email=` (AGL-2622).\n *\n * A whole address is `is`, served by the lower-cased key, so it finds that\n * buyer and no one whose address merely begins the same way. Anything else —\n * a domain, `@acme.com`, a name — is `contains`, a word prefix of the\n * address, so a domain finds every buyer at a company.\n */\nexport function ordersCustomerClause(raw: string): ListFilterClause | null {\n  const value = raw.trim().replace(/^@+/, '')\n  if (!value) return null\n  const at = value.indexOf('@')\n  return at > 0 && at < value.length - 1\n    ? { field: 'customerEmail', op: 'equals', value }\n    : { field: 'customerEmail', op: 'contains', value }\n}\n"],"names":["ORDER_CHANNEL_LABELS","ORDER_STATUS_LABELS","ORDER_LIST_FIELDS","column","kind","path","tokensPath","operators","lowerPath","presence","storedAs","verbatimTokens","ORDER_LIST_QUERY","fields","sorts","direction","search","ORDER_LIST_HEADERS","orderLabel","customerEmail","channelKey","statusKey","createdAtMs","productIds","disputeKey","ORDER_LIST_SELECT_FIELDS","ORDER_STATUS_OPTIONS","Object","keys","map","status","value","label","ORDER_CHANNEL_OPTIONS","channel","ORDER_DISPUTE_OPTIONS","OPEN_DISPUTE_CLAUSE","field","op","ordersCustomerClause","raw","trim","replace","at","indexOf","length"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAQD,SACEA,oBAAoB,EACpBC,mBAAmB,QAGd,8BAA0B;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GAED,kDAAkD,GAClD,OAAO,MAAMC,oBAAgD;IAC3D;QACE,0DAA0D;QAC1DC,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNC,YAAY;QACZC,WAAW;YAAC;SAAW;IACzB;IACA;QACE,qEAAqE;QACrEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNG,WAAW;QACXF,YAAY;QACZC,WAAW;YAAC;YAAY;SAAS;IACnC;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNI,UAAU;QACVF,WAAW;YAAC;YAAU;SAAU;IAClC;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNI,UAAU;QACVF,WAAW;YAAC;YAAU;SAAU;IAClC;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNK,UAAU;QACVD,UAAU;QACVF,WAAW;YAAC;YAAM;YAAS;YAAa;YAAU;SAAa;IACjE;IACA;QACE,mEAAmE;QACnEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNC,YAAY;QACZK,gBAAgB;QAChBJ,WAAW;YAAC;SAAU;IACxB;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNE,WAAW;YAAC;YAAU;SAAU;IAClC;CACD,CAAA;AAED,gEAAgE,GAChE,OAAO,MAAMK,mBAAyC;IACpDC,QAAQX;IACRY,OAAO;QAAC;YAAET,MAAM;YAAeU,WAAW;YAAQZ,QAAQ;QAAc;KAAE;IAC1Ea,QAAQ;QAAEV,YAAY;IAAe;AACvC,EAAC;AAED,OAAO,MAAMW,qBAAuD;IAClEC,YAAY;IACZC,eAAe;IACfC,YAAY;IACZC,WAAW;IACXC,aAAa;IACbC,YAAY;IACZC,YAAY;AACd,EAAC;AAED,uEAAuE,GACvE,OAAO,MAAMC,2BAA8C;IACzD;IACA;IACA;IACA;CACD,CAAA;AAED,OAAO,MAAMC,uBAAoD,AAC/DC,OAAOC,IAAI,CAAC3B,qBACZ4B,GAAG,CAAC,CAACC,SAAY,CAAA;QAAEC,OAAOD;QAAQE,OAAO/B,mBAAmB,CAAC6B,OAAO;IAAC,CAAA,GAAG;AAE1E,OAAO,MAAMG,wBAAqD,AAChEN,OAAOC,IAAI,CAAC5B,sBACZ6B,GAAG,CAAC,CAACK,UAAa,CAAA;QAAEH,OAAOG;QAASF,OAAOhC,oBAAoB,CAACkC,QAAQ;IAAC,CAAA,GAAG;AAE9E;;;;;CAKC,GACD,OAAO,MAAMC,wBAAqD;IAChE;QAAEJ,OAAO;QAAQC,OAAO;IAAe;IACvC;QAAED,OAAO;QAAQC,OAAO;IAAe;IACvC;QAAED,OAAO;QAAOC,OAAO;IAAc;IACrC;QAAED,OAAO;QAAWC,OAAO;IAAiB;CAC7C,CAAA;AAED,2DAA2D,GAC3D,OAAO,MAAMI,sBAAwC;IACnDC,OAAO;IACPC,IAAI;IACJP,OAAO;AACT,EAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAASQ,qBAAqBC,GAAW;IAC9C,MAAMT,QAAQS,IAAIC,IAAI,GAAGC,OAAO,CAAC,OAAO;IACxC,IAAI,CAACX,OAAO,OAAO;IACnB,MAAMY,KAAKZ,MAAMa,OAAO,CAAC;IACzB,OAAOD,KAAK,KAAKA,KAAKZ,MAAMc,MAAM,GAAG,IACjC;QAAER,OAAO;QAAiBC,IAAI;QAAUP;IAAM,IAC9C;QAAEM,OAAO;QAAiBC,IAAI;QAAYP;IAAM;AACtD"}

package/src/lib/constants/product-list-query.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ListFilterField, ListFilterRequest } from '@aglyn/shared-ui-jsx/const/list-filter';
+import type { ListFilterOption } from '@aglyn/shared-ui-jsx/const/list-grid-filter';
+import type { ListQueryDeclaration, ListQueryFilter } from '@aglyn/shared-ui-jsx/const/list-query-plan';
+/** The list's scope: live products only. */
+export declare const PRODUCT_LIST_BASE: readonly ListQueryFilter[];
+/** The scope, as `listQueryIndexes` enumerates it. */
+export declare const PRODUCT_LIST_INDEX_BASE: readonly {
+    path: string;
+    array?: boolean;
+}[];
+export declare const PRODUCT_LIST_FIELDS: readonly ListFilterField[];
+export declare const PRODUCT_LIST_QUERY: ListQueryDeclaration;
+export declare const PRODUCT_LIST_HEADERS: Readonly<Record<string, string>>;
+export declare const PRODUCT_LIST_OPTIONS: Readonly<Record<string, readonly ListFilterOption[]>>;
+/** The fields whose values are picked, which the panel shows as a select. */
+export declare const PRODUCT_LIST_SELECT_FIELDS: readonly string[];
+/**
+ * The clauses as the query must ask them.
+ *
+ * `productSearchFields` stores every SKU and barcode trimmed and lower-cased,
+ * and an array field is matched by whole member, byte for byte — so a SKU
+ * typed `ABC-123` would ask for a member nobody stored. The typed value is
+ * folded the way the writer folded it; `is any of` folds each of its values.
+ * Every other clause passes through as the panel wrote it.
+ */
+export declare function productListRequestClauses<Clause extends ListFilterRequest>(clauses: readonly Clause[]): Clause[];

package/src/lib/constants/product-list-query.js

@@ -0,0 +1,217 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+/*
+ * The products hub's catalog table (`hosts/{hostId}/products`): what its
+ * Filters panel and quick search may ask, and the ONE Firestore query that
+ * answers all of it (AGL-3321).
+ *
+ * Every clause and the search word go on the query and the pages come from
+ * it, so a product on page forty is found exactly as one on page one is. The
+ * card matches nothing over the rows it holds.
+ *
+ * ## The order, and why every product carries its key
+ *
+ * `nameLower` ascending, the one order the list offers. Ordering by a field
+ * drops every document that lacks it, so every writer stamps it through
+ * `productSearchFields` — the editor, Duplicate, the CSV importer and the AI
+ * drafts, all of which create through `/api/hosts/resources` — and
+ * `tools/scripts/backfill-products-list-fields.mjs` stamps it onto the
+ * products written before any of them did.
+ *
+ * ## Soft-deleted products are excluded BY THE QUERY
+ *
+ * `deletedAt` is `null` on a live product and a timestamp on a deleted one.
+ * Firestore cannot ask for a document that LACKS a field, so the list's scope
+ * is `deletedAt == null`, and the create route stamps the explicit `null` on
+ * every product it makes (the backfill stamps the rest). Dropping deleted
+ * rows after the read would leave a page short by however many it dropped.
+ *
+ * ## What is offered, and what is not
+ *
+ *   - Name: `contains` (word prefix, over `nameTokens`), `equals` and
+ *     `startsWith` (over `nameLower`, the field the list is ordered by, so a
+ *     prefix range keeps the order it already has).
+ *   - Status and Type: picked, `is` / `is any of`.
+ *   - Slug: `is`. Slugs are lower-case by construction, so the stored value
+ *     is its own key.
+ *   - SKU and Barcode: WHOLE values, `contains` / `is any of`, over the
+ *     flattened `skus` / `barcodes` arrays — a code is copied or scanned, not
+ *     half-remembered. Stored lower-cased; see `productListRequestClauses`.
+ *
+ * Not offered, and why: price and the created/updated dates are ranges, and a
+ * range must lead the order, so each would add a whole second order's worth
+ * of composites for every field above (and `priceUsd` is the first
+ * variant's price, which describes a multi-variant product wrongly). A
+ * name `endsWith` needs the reversed key as its order for the same reason.
+ * Tags are stored as typed, so a whole-member match would be case-sensitive
+ * where the reader expects it not to be.
+ *
+ * ## The indexes
+ *
+ * One `(field, nameLower ASC)` composite per filterable field and for the
+ * scope, merged by Firestore for any combination:
+ * `listQueryIndexes(PRODUCT_LIST_QUERY, PRODUCT_LIST_INDEX_BASE)`, held to
+ * `cloud/firebase-firestore.indexes.json` by `product-list-query.spec.ts`.
+ */ /** The list's scope: live products only. */ export const PRODUCT_LIST_BASE = [
+    {
+        path: 'deletedAt',
+        op: '==',
+        value: null
+    }
+];
+/** The scope, as `listQueryIndexes` enumerates it. */ export const PRODUCT_LIST_INDEX_BASE = [
+    {
+        path: 'deletedAt'
+    }
+];
+export const PRODUCT_LIST_FIELDS = [
+    {
+        column: 'name',
+        kind: 'text',
+        path: 'name',
+        lowerPath: 'nameLower',
+        tokensPath: 'nameTokens',
+        operators: [
+            'contains',
+            'equals',
+            'startsWith'
+        ]
+    },
+    {
+        column: 'status',
+        kind: 'exact',
+        path: 'status',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'type',
+        kind: 'exact',
+        path: 'type',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'slug',
+        kind: 'text',
+        path: 'slug',
+        lowerPath: 'slug',
+        operators: [
+            'equals'
+        ]
+    },
+    {
+        column: 'skus',
+        kind: 'exact',
+        path: 'skus',
+        tokensPath: 'skus',
+        operators: [
+            'contains',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'barcodes',
+        kind: 'exact',
+        path: 'barcodes',
+        tokensPath: 'barcodes',
+        operators: [
+            'contains',
+            'isAnyOf'
+        ]
+    }
+];
+export const PRODUCT_LIST_QUERY = {
+    fields: PRODUCT_LIST_FIELDS,
+    sorts: [
+        {
+            path: 'nameLower',
+            direction: 'asc',
+            column: 'name'
+        }
+    ],
+    search: {
+        tokensPath: 'nameTokens'
+    }
+};
+export const PRODUCT_LIST_HEADERS = {
+    name: 'Product',
+    status: 'Status',
+    type: 'Type',
+    slug: 'Slug',
+    skus: 'SKU',
+    barcodes: 'Barcode'
+};
+export const PRODUCT_LIST_OPTIONS = {
+    status: [
+        {
+            value: 'active',
+            label: 'Active'
+        },
+        {
+            value: 'draft',
+            label: 'Draft'
+        },
+        {
+            value: 'archived',
+            label: 'Archived'
+        }
+    ],
+    type: [
+        {
+            value: 'physical',
+            label: 'Physical'
+        },
+        {
+            value: 'digital',
+            label: 'Digital'
+        },
+        {
+            value: 'service',
+            label: 'Service'
+        }
+    ]
+};
+/** The fields whose values are picked, which the panel shows as a select. */ export const PRODUCT_LIST_SELECT_FIELDS = Object.keys(PRODUCT_LIST_OPTIONS);
+/** The columns folded to lower case before they reach the query. */ const FOLDED = new Set([
+    'skus',
+    'barcodes'
+]);
+/**
+ * The clauses as the query must ask them.
+ *
+ * `productSearchFields` stores every SKU and barcode trimmed and lower-cased,
+ * and an array field is matched by whole member, byte for byte — so a SKU
+ * typed `ABC-123` would ask for a member nobody stored. The typed value is
+ * folded the way the writer folded it; `is any of` folds each of its values.
+ * Every other clause passes through as the panel wrote it.
+ */ export function productListRequestClauses(clauses) {
+    const fold = (value)=>value.trim().toLowerCase();
+    return clauses.map((clause)=>{
+        if (!FOLDED.has(clause.field)) return clause;
+        const value = clause.op === 'isAnyOf' ? clause.value.split(',').map(fold).filter(Boolean).join(',') : fold(clause.value);
+        return _extends({}, clause, {
+            value
+        });
+    });
+}
+
+//# sourceMappingURL=product-list-query.js.map

package/src/lib/constants/product-list-query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/constants/product-list-query.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\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 *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\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 type {\n  ListFilterField,\n  ListFilterRequest,\n} from '@aglyn/shared-ui-jsx/const/list-filter'\nimport type { ListFilterOption } from '@aglyn/shared-ui-jsx/const/list-grid-filter'\nimport type {\n  ListQueryDeclaration,\n  ListQueryFilter,\n} from '@aglyn/shared-ui-jsx/const/list-query-plan'\n\n/*\n * The products hub's catalog table (`hosts/{hostId}/products`): what its\n * Filters panel and quick search may ask, and the ONE Firestore query that\n * answers all of it (AGL-3321).\n *\n * Every clause and the search word go on the query and the pages come from\n * it, so a product on page forty is found exactly as one on page one is. The\n * card matches nothing over the rows it holds.\n *\n * ## The order, and why every product carries its key\n *\n * `nameLower` ascending, the one order the list offers. Ordering by a field\n * drops every document that lacks it, so every writer stamps it through\n * `productSearchFields` — the editor, Duplicate, the CSV importer and the AI\n * drafts, all of which create through `/api/hosts/resources` — and\n * `tools/scripts/backfill-products-list-fields.mjs` stamps it onto the\n * products written before any of them did.\n *\n * ## Soft-deleted products are excluded BY THE QUERY\n *\n * `deletedAt` is `null` on a live product and a timestamp on a deleted one.\n * Firestore cannot ask for a document that LACKS a field, so the list's scope\n * is `deletedAt == null`, and the create route stamps the explicit `null` on\n * every product it makes (the backfill stamps the rest). Dropping deleted\n * rows after the read would leave a page short by however many it dropped.\n *\n * ## What is offered, and what is not\n *\n *   - Name: `contains` (word prefix, over `nameTokens`), `equals` and\n *     `startsWith` (over `nameLower`, the field the list is ordered by, so a\n *     prefix range keeps the order it already has).\n *   - Status and Type: picked, `is` / `is any of`.\n *   - Slug: `is`. Slugs are lower-case by construction, so the stored value\n *     is its own key.\n *   - SKU and Barcode: WHOLE values, `contains` / `is any of`, over the\n *     flattened `skus` / `barcodes` arrays — a code is copied or scanned, not\n *     half-remembered. Stored lower-cased; see `productListRequestClauses`.\n *\n * Not offered, and why: price and the created/updated dates are ranges, and a\n * range must lead the order, so each would add a whole second order's worth\n * of composites for every field above (and `priceUsd` is the first\n * variant's price, which describes a multi-variant product wrongly). A\n * name `endsWith` needs the reversed key as its order for the same reason.\n * Tags are stored as typed, so a whole-member match would be case-sensitive\n * where the reader expects it not to be.\n *\n * ## The indexes\n *\n * One `(field, nameLower ASC)` composite per filterable field and for the\n * scope, merged by Firestore for any combination:\n * `listQueryIndexes(PRODUCT_LIST_QUERY, PRODUCT_LIST_INDEX_BASE)`, held to\n * `cloud/firebase-firestore.indexes.json` by `product-list-query.spec.ts`.\n */\n\n/** The list's scope: live products only. */\nexport const PRODUCT_LIST_BASE: readonly ListQueryFilter[] = [\n  { path: 'deletedAt', op: '==', value: null },\n]\n\n/** The scope, as `listQueryIndexes` enumerates it. */\nexport const PRODUCT_LIST_INDEX_BASE: readonly { path: string; array?: boolean }[] = [\n  { path: 'deletedAt' },\n]\n\nexport const PRODUCT_LIST_FIELDS: readonly ListFilterField[] = [\n  {\n    column: 'name',\n    kind: 'text',\n    path: 'name',\n    lowerPath: 'nameLower',\n    tokensPath: 'nameTokens',\n    operators: ['contains', 'equals', 'startsWith'],\n  },\n  { column: 'status', kind: 'exact', path: 'status', operators: ['equals', 'isAnyOf'] },\n  { column: 'type', kind: 'exact', path: 'type', operators: ['equals', 'isAnyOf'] },\n  { column: 'slug', kind: 'text', path: 'slug', lowerPath: 'slug', operators: ['equals'] },\n  {\n    column: 'skus',\n    kind: 'exact',\n    path: 'skus',\n    tokensPath: 'skus',\n    operators: ['contains', 'isAnyOf'],\n  },\n  {\n    column: 'barcodes',\n    kind: 'exact',\n    path: 'barcodes',\n    tokensPath: 'barcodes',\n    operators: ['contains', 'isAnyOf'],\n  },\n]\n\nexport const PRODUCT_LIST_QUERY: ListQueryDeclaration = {\n  fields: PRODUCT_LIST_FIELDS,\n  sorts: [{ path: 'nameLower', direction: 'asc', column: 'name' }],\n  search: { tokensPath: 'nameTokens' },\n}\n\nexport const PRODUCT_LIST_HEADERS: Readonly<Record<string, string>> = {\n  name: 'Product',\n  status: 'Status',\n  type: 'Type',\n  slug: 'Slug',\n  skus: 'SKU',\n  barcodes: 'Barcode',\n}\n\nexport const PRODUCT_LIST_OPTIONS: Readonly<Record<string, readonly ListFilterOption[]>> = {\n  status: [\n    { value: 'active', label: 'Active' },\n    { value: 'draft', label: 'Draft' },\n    { value: 'archived', label: 'Archived' },\n  ],\n  type: [\n    { value: 'physical', label: 'Physical' },\n    { value: 'digital', label: 'Digital' },\n    { value: 'service', label: 'Service' },\n  ],\n}\n\n/** The fields whose values are picked, which the panel shows as a select. */\nexport const PRODUCT_LIST_SELECT_FIELDS: readonly string[] = Object.keys(PRODUCT_LIST_OPTIONS)\n\n/** The columns folded to lower case before they reach the query. */\nconst FOLDED = new Set(['skus', 'barcodes'])\n\n/**\n * The clauses as the query must ask them.\n *\n * `productSearchFields` stores every SKU and barcode trimmed and lower-cased,\n * and an array field is matched by whole member, byte for byte — so a SKU\n * typed `ABC-123` would ask for a member nobody stored. The typed value is\n * folded the way the writer folded it; `is any of` folds each of its values.\n * Every other clause passes through as the panel wrote it.\n */\nexport function productListRequestClauses<Clause extends ListFilterRequest>(\n  clauses: readonly Clause[],\n): Clause[] {\n  const fold = (value: string) => value.trim().toLowerCase()\n  return clauses.map((clause) => {\n    if (!FOLDED.has(clause.field)) return clause\n    const value =\n      clause.op === 'isAnyOf'\n        ? clause.value.split(',').map(fold).filter(Boolean).join(',')\n        : fold(clause.value)\n    return { ...clause, value }\n  })\n}\n"],"names":["PRODUCT_LIST_BASE","path","op","value","PRODUCT_LIST_INDEX_BASE","PRODUCT_LIST_FIELDS","column","kind","lowerPath","tokensPath","operators","PRODUCT_LIST_QUERY","fields","sorts","direction","search","PRODUCT_LIST_HEADERS","name","status","type","slug","skus","barcodes","PRODUCT_LIST_OPTIONS","label","PRODUCT_LIST_SELECT_FIELDS","Object","keys","FOLDED","Set","productListRequestClauses","clauses","fold","trim","toLowerCase","map","clause","has","field","split","filter","Boolean","join"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDC,GAED,0CAA0C,GAC1C,OAAO,MAAMA,oBAAgD;IAC3D;QAAEC,MAAM;QAAaC,IAAI;QAAMC,OAAO;IAAK;CAC5C,CAAA;AAED,oDAAoD,GACpD,OAAO,MAAMC,0BAAwE;IACnF;QAAEH,MAAM;IAAY;CACrB,CAAA;AAED,OAAO,MAAMI,sBAAkD;IAC7D;QACEC,QAAQ;QACRC,MAAM;QACNN,MAAM;QACNO,WAAW;QACXC,YAAY;QACZC,WAAW;YAAC;YAAY;YAAU;SAAa;IACjD;IACA;QAAEJ,QAAQ;QAAUC,MAAM;QAASN,MAAM;QAAUS,WAAW;YAAC;YAAU;SAAU;IAAC;IACpF;QAAEJ,QAAQ;QAAQC,MAAM;QAASN,MAAM;QAAQS,WAAW;YAAC;YAAU;SAAU;IAAC;IAChF;QAAEJ,QAAQ;QAAQC,MAAM;QAAQN,MAAM;QAAQO,WAAW;QAAQE,WAAW;YAAC;SAAS;IAAC;IACvF;QACEJ,QAAQ;QACRC,MAAM;QACNN,MAAM;QACNQ,YAAY;QACZC,WAAW;YAAC;YAAY;SAAU;IACpC;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNN,MAAM;QACNQ,YAAY;QACZC,WAAW;YAAC;YAAY;SAAU;IACpC;CACD,CAAA;AAED,OAAO,MAAMC,qBAA2C;IACtDC,QAAQP;IACRQ,OAAO;QAAC;YAAEZ,MAAM;YAAaa,WAAW;YAAOR,QAAQ;QAAO;KAAE;IAChES,QAAQ;QAAEN,YAAY;IAAa;AACrC,EAAC;AAED,OAAO,MAAMO,uBAAyD;IACpEC,MAAM;IACNC,QAAQ;IACRC,MAAM;IACNC,MAAM;IACNC,MAAM;IACNC,UAAU;AACZ,EAAC;AAED,OAAO,MAAMC,uBAA8E;IACzFL,QAAQ;QACN;YAAEf,OAAO;YAAUqB,OAAO;QAAS;QACnC;YAAErB,OAAO;YAASqB,OAAO;QAAQ;QACjC;YAAErB,OAAO;YAAYqB,OAAO;QAAW;KACxC;IACDL,MAAM;QACJ;YAAEhB,OAAO;YAAYqB,OAAO;QAAW;QACvC;YAAErB,OAAO;YAAWqB,OAAO;QAAU;QACrC;YAAErB,OAAO;YAAWqB,OAAO;QAAU;KACtC;AACH,EAAC;AAED,2EAA2E,GAC3E,OAAO,MAAMC,6BAAgDC,OAAOC,IAAI,CAACJ,sBAAqB;AAE9F,kEAAkE,GAClE,MAAMK,SAAS,IAAIC,IAAI;IAAC;IAAQ;CAAW;AAE3C;;;;;;;;CAQC,GACD,OAAO,SAASC,0BACdC,OAA0B;IAE1B,MAAMC,OAAO,CAAC7B,QAAkBA,MAAM8B,IAAI,GAAGC,WAAW;IACxD,OAAOH,QAAQI,GAAG,CAAC,CAACC;QAClB,IAAI,CAACR,OAAOS,GAAG,CAACD,OAAOE,KAAK,GAAG,OAAOF;QACtC,MAAMjC,QACJiC,OAAOlC,EAAE,KAAK,YACVkC,OAAOjC,KAAK,CAACoC,KAAK,CAAC,KAAKJ,GAAG,CAACH,MAAMQ,MAAM,CAACC,SAASC,IAAI,CAAC,OACvDV,KAAKI,OAAOjC,KAAK;QACvB,OAAO,aAAKiC;YAAQjC;;IACtB;AACF"}

package/src/lib/constants/stock-movement-query.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter';
+import type { ListQueryDeclaration } from '@aglyn/shared-ui-jsx/const/list-query-plan';
+import type { InventoryAdjustmentReason } from '../model/commerce';
+export declare const STOCK_MOVEMENT_FILTER_FIELDS: readonly ListFilterField[];
+/** The ledger's one order: newest first, the order every writer stamps. */
+export declare const STOCK_MOVEMENT_QUERY: ListQueryDeclaration;
+export declare const STOCK_MOVEMENT_FILTER_HEADERS: Readonly<Record<string, string>>;
+/** The fields picked from choices rather than typed. */
+export declare const STOCK_MOVEMENT_SELECT_FIELDS: readonly string[];
+/** The stored key is a closed set; these are what a merchant reads. */
+export declare const STOCK_MOVEMENT_REASON_LABEL: Readonly<Record<InventoryAdjustmentReason, string>>;

package/src/lib/constants/stock-movement-query.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /*
+ * What the stock movements ledger filters by, and how its query serves it
+ * (AGL-3321).
+ *
+ * Every field is one every writer of `hosts/{hostId}/inventoryAdjustments`
+ * already stores — the "Adjust stock" dialog, the sale path
+ * (`decrementVariantStock`) and the cancellation restock — so nothing new is
+ * written and nothing needs a backfill. Each is an EQUALITY beneath the
+ * ledger's one order, `atMs` newest first, which is one `(field, atMs DESC)`
+ * composite per field under index merging; the date filter is a range on
+ * `atMs` itself, the order the ledger is already in, so it costs nothing.
+ *
+ * Order and location are typed or picked ids, matched whole. A sparse field
+ * answers `equals` exactly — a row with no order is simply not that order —
+ * and offers no "is set", which would be an inequality on a second field.
+ *
+ * No quick search. The ledger's rows name a product by id; the name a reader
+ * would type lives on the product, so a search could only ever match the
+ * names of the rows already loaded. Product is a picked filter instead, and
+ * the ids the old search read (order, location) are filters of their own.
+ */ export const STOCK_MOVEMENT_FILTER_FIELDS = [
+    {
+        column: 'productId',
+        kind: 'exact',
+        path: 'productId',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'reason',
+        kind: 'exact',
+        path: 'reason',
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: 'atMs',
+        kind: 'date',
+        path: 'atMs',
+        storedAs: 'millis',
+        presence: 'always'
+    },
+    {
+        column: 'orderId',
+        kind: 'exact',
+        path: 'orderId',
+        operators: [
+            'equals'
+        ]
+    },
+    {
+        column: 'locationId',
+        kind: 'exact',
+        path: 'locationId',
+        operators: [
+            'equals'
+        ]
+    }
+];
+/** The ledger's one order: newest first, the order every writer stamps. */ export const STOCK_MOVEMENT_QUERY = {
+    fields: STOCK_MOVEMENT_FILTER_FIELDS,
+    sorts: [
+        {
+            path: 'atMs',
+            direction: 'desc',
+            column: 'atMs'
+        }
+    ]
+};
+export const STOCK_MOVEMENT_FILTER_HEADERS = {
+    productId: 'Product',
+    reason: 'Reason',
+    atMs: 'When',
+    orderId: 'Order',
+    locationId: 'Location'
+};
+/** The fields picked from choices rather than typed. */ export const STOCK_MOVEMENT_SELECT_FIELDS = [
+    'productId',
+    'reason',
+    'locationId'
+];
+/** The stored key is a closed set; these are what a merchant reads. */ export const STOCK_MOVEMENT_REASON_LABEL = {
+    sale: 'Sale',
+    refund: 'Refund return',
+    restock: 'Restock',
+    correction: 'Correction',
+    damage: 'Damaged',
+    cancellation: 'Order canceled'
+};
+
+//# sourceMappingURL=stock-movement-query.js.map

package/src/lib/constants/stock-movement-query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/constants/stock-movement-query.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\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 *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\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 type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter'\nimport type { ListQueryDeclaration } from '@aglyn/shared-ui-jsx/const/list-query-plan'\nimport type { InventoryAdjustmentReason } from '../model/commerce'\n\n/*\n * What the stock movements ledger filters by, and how its query serves it\n * (AGL-3321).\n *\n * Every field is one every writer of `hosts/{hostId}/inventoryAdjustments`\n * already stores — the \"Adjust stock\" dialog, the sale path\n * (`decrementVariantStock`) and the cancellation restock — so nothing new is\n * written and nothing needs a backfill. Each is an EQUALITY beneath the\n * ledger's one order, `atMs` newest first, which is one `(field, atMs DESC)`\n * composite per field under index merging; the date filter is a range on\n * `atMs` itself, the order the ledger is already in, so it costs nothing.\n *\n * Order and location are typed or picked ids, matched whole. A sparse field\n * answers `equals` exactly — a row with no order is simply not that order —\n * and offers no \"is set\", which would be an inequality on a second field.\n *\n * No quick search. The ledger's rows name a product by id; the name a reader\n * would type lives on the product, so a search could only ever match the\n * names of the rows already loaded. Product is a picked filter instead, and\n * the ids the old search read (order, location) are filters of their own.\n */\nexport const STOCK_MOVEMENT_FILTER_FIELDS: readonly ListFilterField[] = [\n  { column: 'productId', kind: 'exact', path: 'productId', operators: ['equals', 'isAnyOf'] },\n  { column: 'reason', kind: 'exact', path: 'reason', operators: ['equals', 'isAnyOf'] },\n  { column: 'atMs', kind: 'date', path: 'atMs', storedAs: 'millis', presence: 'always' },\n  { column: 'orderId', kind: 'exact', path: 'orderId', operators: ['equals'] },\n  { column: 'locationId', kind: 'exact', path: 'locationId', operators: ['equals'] },\n]\n\n/** The ledger's one order: newest first, the order every writer stamps. */\nexport const STOCK_MOVEMENT_QUERY: ListQueryDeclaration = {\n  fields: STOCK_MOVEMENT_FILTER_FIELDS,\n  sorts: [{ path: 'atMs', direction: 'desc', column: 'atMs' }],\n}\n\nexport const STOCK_MOVEMENT_FILTER_HEADERS: Readonly<Record<string, string>> = {\n  productId: 'Product',\n  reason: 'Reason',\n  atMs: 'When',\n  orderId: 'Order',\n  locationId: 'Location',\n}\n\n/** The fields picked from choices rather than typed. */\nexport const STOCK_MOVEMENT_SELECT_FIELDS: readonly string[] = ['productId', 'reason', 'locationId']\n\n/** The stored key is a closed set; these are what a merchant reads. */\nexport const STOCK_MOVEMENT_REASON_LABEL: Readonly<Record<InventoryAdjustmentReason, string>> = {\n  sale: 'Sale',\n  refund: 'Refund return',\n  restock: 'Restock',\n  correction: 'Correction',\n  damage: 'Damaged',\n  cancellation: 'Order canceled',\n}\n"],"names":["STOCK_MOVEMENT_FILTER_FIELDS","column","kind","path","operators","storedAs","presence","STOCK_MOVEMENT_QUERY","fields","sorts","direction","STOCK_MOVEMENT_FILTER_HEADERS","productId","reason","atMs","orderId","locationId","STOCK_MOVEMENT_SELECT_FIELDS","STOCK_MOVEMENT_REASON_LABEL","sale","refund","restock","correction","damage","cancellation"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAMD;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,MAAMA,+BAA2D;IACtE;QAAEC,QAAQ;QAAaC,MAAM;QAASC,MAAM;QAAaC,WAAW;YAAC;YAAU;SAAU;IAAC;IAC1F;QAAEH,QAAQ;QAAUC,MAAM;QAASC,MAAM;QAAUC,WAAW;YAAC;YAAU;SAAU;IAAC;IACpF;QAAEH,QAAQ;QAAQC,MAAM;QAAQC,MAAM;QAAQE,UAAU;QAAUC,UAAU;IAAS;IACrF;QAAEL,QAAQ;QAAWC,MAAM;QAASC,MAAM;QAAWC,WAAW;YAAC;SAAS;IAAC;IAC3E;QAAEH,QAAQ;QAAcC,MAAM;QAASC,MAAM;QAAcC,WAAW;YAAC;SAAS;IAAC;CAClF,CAAA;AAED,yEAAyE,GACzE,OAAO,MAAMG,uBAA6C;IACxDC,QAAQR;IACRS,OAAO;QAAC;YAAEN,MAAM;YAAQO,WAAW;YAAQT,QAAQ;QAAO;KAAE;AAC9D,EAAC;AAED,OAAO,MAAMU,gCAAkE;IAC7EC,WAAW;IACXC,QAAQ;IACRC,MAAM;IACNC,SAAS;IACTC,YAAY;AACd,EAAC;AAED,sDAAsD,GACtD,OAAO,MAAMC,+BAAkD;IAAC;IAAa;IAAU;CAAa,CAAA;AAEpG,qEAAqE,GACrE,OAAO,MAAMC,8BAAmF;IAC9FC,MAAM;IACNC,QAAQ;IACRC,SAAS;IACTC,YAAY;IACZC,QAAQ;IACRC,cAAc;AAChB,EAAC"}