@youzan-cloud/zan-saas-cli 0.1.0-beta.4 → 0.1.0-beta.8

package/src/commands/native/order/order/scan/schema.json

@@ -231,12 +231,34 @@
     "additionalProperties": false,
     "properties": {
       "requests": {
-        "type": "array",
-        "minItems": 1,
-        "maxItems": 1,
-        "items": {
-          "$ref": "#/definitions/bindingRequest"
-        }
+        "description": "同店保留原计划；总部显式分店先核实总部、在其目录中有界核实成员、绑定分店，再读订单。目录项展示第一页模板，最多20页，不表示已核实。",
+        "anyOf": [
+          {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 1,
+            "items": {
+              "$ref": "#/definitions/bindingRequest"
+            }
+          },
+          {
+            "type": "array",
+            "minItems": 3,
+            "maxItems": 3,
+            "additionalItems": false,
+            "items": [
+              {
+                "$ref": "#/definitions/headquartersBindingRequest"
+              },
+              {
+                "$ref": "#/definitions/membershipRequest"
+              },
+              {
+                "$ref": "#/definitions/targetBindingRequest"
+              }
+            ]
+          }
+        ]
       },
       "initialRanges": {
         "type": "array",
@@ -347,7 +369,9 @@
               "order",
               "orders",
               "scan",
-              "output-model"
+              "output-model",
+              "headquarters-binding",
+              "target-membership"
             ]
           },
           "command": {
@@ -1352,6 +1376,106 @@
           "description": "本地已进入发送边界的观测次数下界，不是服务端执行次数。"
         }
       }
+    },
+    "headquartersBindingRequest": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "method": {
+          "const": "POST"
+        },
+        "path": {
+          "const": "youzan.shop.basic.get/3.0.0"
+        },
+        "body": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {},
+          "required": []
+        },
+        "stage": {
+          "const": "headquarters-binding"
+        },
+        "kdtId": {
+          "$ref": "#/definitions/shopId"
+        }
+      },
+      "required": [
+        "method",
+        "path",
+        "body",
+        "stage",
+        "kdtId"
+      ]
+    },
+    "targetBindingRequest": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "method": {
+          "const": "POST"
+        },
+        "path": {
+          "const": "youzan.shop.basic.get/3.0.0"
+        },
+        "body": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {},
+          "required": []
+        },
+        "stage": {
+          "const": "shop-binding"
+        },
+        "kdtId": {
+          "$ref": "#/definitions/shopId"
+        }
+      },
+      "required": [
+        "method",
+        "path",
+        "body",
+        "stage",
+        "kdtId"
+      ]
+    },
+    "membershipRequest": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "method": {
+          "const": "POST"
+        },
+        "path": {
+          "const": "youzan.shop.chain.descendent.organization.list/1.0.1"
+        },
+        "body": {
+          "const": {
+            "page_num": 1,
+            "page_size": 50,
+            "with_dept_info": false,
+            "with_shop_status_and_lifecycle_end_time": false,
+            "with_crm_shop": false
+          }
+        },
+        "stage": {
+          "const": "target-membership"
+        },
+        "kdtId": {
+          "$ref": "#/definitions/shopId"
+        },
+        "maxPages": {
+          "const": 20
+        }
+      },
+      "required": [
+        "method",
+        "path",
+        "body",
+        "stage",
+        "kdtId",
+        "maxPages"
+      ]
     }
   },
   "modules": {
@@ -1440,6 +1564,9 @@
     "应用凭证实测不证明店铺员工身份授权与权限隔离。",
     "商品行 item_id/sku_id 为OneID，channel_item_id/channel_sku_id 为历史渠道身份；oid仍为交易行，不用当前档案重写历史。",
     "历史统一商品或规格字段为空字符串时，省略对应OneID并保留明确渠道身份，不用渠道ID补造；null和其他错型仍失败。",
-    "时间区间必须包含 .. 并显式两端；不接受旧成对参数或裸时间等值，非零毫秒在请求前拒绝。"
+    "时间区间必须包含 .. 并显式两端；不接受旧成对参数或裸时间等值，非零毫秒在请求前拒绝。",
+    "省略 --kdt-id 只查 context.shopId，总部默认仅总部本身，不包含分店。总部显式分店目标先核验总部角色及sid，再查下级组织目录，最后绑定分店sid；已返回的总部字段必须一致。查询不保存位置，不扩大解密权限。",
+    "成员核验每页50条、最多20页。目录完整未命中为permission，未读完为scope_unresolved，字段异常为protocol；接口拒绝保留阶段与安全诊断。空订单也不能绕过前置。新增请求共享累计响应预算，同店请求保持兼容。",
+    "所有总部、目录、分店绑定、探测与翻页请求均计入maxRequests，发送前检查；前置未完成即预算耗尽时失败，不输出未核实的订单或零值。"
   ]
 }

package/src/commands/native/order/shared/query.js

@@ -1,7 +1,9 @@
 'use strict';
 
 const { resolveTargetShop } = require('../../../../execution/target-shop');
-const { createShopQuery, bindingPath, failure } = require('../../../../execution/shop-query');
+const { createBoundShopQuery, bindingPath, failure } = require('../../../../execution/shop-query');
+const { organizationPath, organizationBody, maxOrganizationPages,
+  verifyMembership } = require('../../../../identity/unit-membership');
 const { parseIncludeModules } = require('../../../../execution/command-io');
 const { copyErrorDetails } = require('../../../../execution/error-details');
 
@@ -10,7 +12,7 @@ const OUTPUT_LIMIT = 5 * 1024 * 1024;
 
 function reject(command, category, stage, scope = {}, requestState = 'not_sent', facts = {}) {
   const error = failure(command, category, stage, scope, requestState, facts);
-  error.cliDetails.nextStep = stage === 'shop-binding' ?
+  error.cliDetails.nextStep = ['headquarters-binding', 'target-membership', 'shop-binding'].includes(stage) ?
     '主订单请求尚未发送。核对原凭证绑定店铺与显式目标，不自动重试、切店或换身份。' :
     category === 'limit' ? '本次结果超出字节限制，未输出部分订单；停止并核对原范围，不截断或自动重试。' :
       '核对原店铺、订单号、上下文与服务端授权；结构不符时停止，不自动重试、解密或换身份。';
@@ -49,21 +51,67 @@ function includes(value, allowed, command, scope) {
   catch { throw reject(command, 'validation', 'input', scope); }
 }
 
+function bindingPreview(scope, context) {
+  const target = { method: 'POST', path: bindingPath, body: {} };
+  if (context?.orgType !== 'hq' || scope.kdtId === context.shopId) return [target];
+  return [
+    { ...target, stage: 'headquarters-binding', kdtId: context.hq },
+    { method: 'POST', path: organizationPath, body: organizationBody(1),
+      stage: 'target-membership', kdtId: context.hq, maxPages: maxOrganizationPages },
+    { ...target, stage: 'shop-binding', kdtId: scope.kdtId }
+  ];
+}
+
 async function createOrderQuery(scope, command, { responseLimit = RESPONSE_LIMIT, onRequest,
-  bounded = false, shopApp } = {}) {
+  bounded = false, shopApp = false, context, maxRequests = maxOrganizationPages + 3 } = {}) {
   let responseBytes = 0;
+  let requests = 0;
+  let requestStage;
+  function beforeRequest(path, stage) {
+    if (requests >= maxRequests || responseBytes >= responseLimit) {
+      throw reject(command, 'limit', stage, scope, 'not_sent', { api: path });
+    }
+    requests++;
+    requestStage = stage;
+  }
   function onResponse(response, path) {
     responseBytes += response.responseBytes;
     if (responseBytes > responseLimit) {
-      throw reject(command, 'limit', path === bindingPath ? 'shop-binding' : 'order', scope,
+      throw reject(command, 'limit', requestStage, scope,
         'sent', { api: path, httpStatus: response.httpStatus });
     }
   }
   try {
-    const read = await createShopQuery({ kdtId: Number(scope.kdtId) }, command, {
-      onResponse, transportOptions: { onRequest, shopApp,
-        maxResponseBytes: bounded ? () => responseLimit - responseBytes : undefined }
-    });
+    const options = { beforeRequest, onResponse, transportOptions: { onRequest, shopApp,
+      maxResponseBytes: bounded ? () => responseLimit - responseBytes : undefined } };
+    let environment;
+    const crossShop = context?.orgType === 'hq' && scope.kdtId !== context.shopId;
+    if (crossShop) {
+      const root = await createBoundShopQuery({ kdtId: Number(context.hq) }, command,
+        'headquarters-binding', { ...options, transportOptions: { ...options.transportOptions, shopApp: false } });
+      if (context.shopId !== context.hq || root.binding.data.role !== 1) {
+        throw reject(command, 'scope_unresolved', 'headquarters-binding', scope, 'sent', root.binding.facts);
+      }
+      const member = await verifyMembership(root.read, scope.kdtId,
+        (category, stage, state, facts) => reject(command, category, stage, scope, state, facts),
+        { notFoundCategory: 'permission' });
+      if (![2001, 2002].includes(member.role)) {
+        throw reject(command, 'permission', 'target-membership', scope, 'sent');
+      }
+      environment = root.environment;
+    }
+    const target = await createBoundShopQuery({ kdtId: Number(scope.kdtId) }, command,
+      'shop-binding', { ...options, environment,
+        transportOptions: { ...options.transportOptions, ...(crossShop && { shopApp: false }) } });
+    if (crossShop && Object.hasOwn(target.binding.data, 'root_kdt_id')) {
+      if (!Number.isSafeInteger(target.binding.data.root_kdt_id) || target.binding.data.root_kdt_id < 1) {
+        throw reject(command, 'protocol', 'shop-binding', scope, 'sent', target.binding.facts);
+      }
+      if (String(target.binding.data.root_kdt_id) !== context.hq) {
+        throw reject(command, 'scope_unresolved', 'shop-binding', scope, 'sent', target.binding.facts);
+      }
+    }
+    const read = target.read;
     return async (path, body, stage = 'order') => {
       try { return await read(path, body, stage); }
       catch (error) { throw adaptError(error, command, scope); }
@@ -80,5 +128,5 @@ function serialize(output, format, command, scope, outputLimit = OUTPUT_LIMIT) {
 }
 
 module.exports = {
-  bindingPath, reject, targetScope, includes, createOrderQuery, serialize, RESPONSE_LIMIT, OUTPUT_LIMIT
+  bindingPath, bindingPreview, reject, targetScope, includes, createOrderQuery, serialize, RESPONSE_LIMIT, OUTPUT_LIMIT
 };

package/src/commands/native/order/shared/search.js

@@ -97,7 +97,7 @@ function adaptPage(data, input, context, facts, command = 'order.order.list') {
 }
 
 async function createOrderPageReader(scope, context, command, options) {
-  const read = await createOrderQuery(scope, command, options);
+  const read = await createOrderQuery(scope, command, { ...options, context });
   return async input => {
     const { pageNo, pageSize } = input.pagination;
     if (input.scope.kdtId !== scope.kdtId || !Number.isSafeInteger(pageNo) || pageNo < 1 || pageNo > 100 ||

package/src/commands/native/org/commands.index.json

@@ -9,7 +9,7 @@
       "availability": "available",
       "at": "shop",
       "module": "org/staff/get/command.js",
-      "fingerprint": "0e6c6fd91988b916f4d5690677c712059ec65f7d6ce003eed7d7192ce61f6d96"
+      "fingerprint": "d35a2747712ebbd21c5bce834a71328620c2787a5bb1573ae9131021f7557b4e"
     },
     {
       "path": "org.staff-role.get",
@@ -18,7 +18,7 @@
       "availability": "available",
       "at": "shop",
       "module": "org/staff-role/get/command.js",
-      "fingerprint": "cfa719f5122449c0a57e5db59bfd760d17d717f95088c9d886586b53304a7041"
+      "fingerprint": "811c7e532d54d940f706d16a7515d1fc8bb4ff42d6274ec77522d3883ad85e97"
     },
     {
       "path": "org.unit.get",
@@ -27,7 +27,7 @@
       "availability": "available",
       "at": "all",
       "module": "org/unit/get/command.js",
-      "fingerprint": "d11775de4f1c6d7500310c3f8b373bee7e829ab5afe586ae617037571b4d0597"
+      "fingerprint": "19198e6fe03e50b0852f103b5a021f83e6d4de7372590374c68be60ac74d8571"
     },
     {
       "path": "org.unit.list",
@@ -36,7 +36,7 @@
       "availability": "available",
       "at": "hq",
       "module": "org/unit/list/command.js",
-      "fingerprint": "6bee5cdcffb1893319280f50f9b49e752d16dbadcae5413bce3bbfcf476a9fc6"
+      "fingerprint": "898b0604f54d2ae28724e816eb1ffd0ada2fd544ed7aa0c69fffc3958f3408ce"
     }
   ]
 }

package/src/commands/native/valuecard/commands.index.json

@@ -9,7 +9,7 @@
       "availability": "available",
       "at": "all",
       "module": "valuecard/card/get/command.js",
-      "fingerprint": "d5819f697caf55a03a7a111abfa9c86764fb2597a536be9e5e5d705c1a91829e"
+      "fingerprint": "c8456b31165de4102619f8ceaa6be3d172ffaa997e7ec1d1ae59c80e0fb3438d"
     },
     {
       "path": "valuecard.card.list",
@@ -18,7 +18,25 @@
       "availability": "available",
       "at": "all",
       "module": "valuecard/card/list/command.js",
-      "fingerprint": "d96d40fd6d68d96f62a809de403fe79274bb4ed671fd166eb6ecba22acd55179"
+      "fingerprint": "d353ad89174f2ebec068d9073a6765c637c02cfb644bc3cdfdf3c3f80fa578d9"
+    },
+    {
+      "path": "valuecard.transaction.list",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "all",
+      "module": "valuecard/transaction/list/command.js",
+      "fingerprint": "32269b8370250350f36c8069306d531111b6c283ff0f20d97de04c318f9e2f44"
+    },
+    {
+      "path": "valuecard.transaction.scan",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "all",
+      "module": "valuecard/transaction/scan/command.js",
+      "fingerprint": "ad4226dd57317e497547b5bc690131009d1b9da2e3e52115b4c006653d89e443"
     }
   ]
 }

package/src/commands/native/valuecard/domain.json

@@ -1,3 +1,3 @@
 {
-  "description": "储值卡：余额卡与礼品卡的资产和余额"
+  "description": "储值卡：余额卡与礼品卡的资产、余额、单页流水及有界精确查找"
 }

package/src/commands/native/valuecard/transaction/list/command.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const { Option } = require('commander');
+const { DiagnosticCommand } = require('../../../../../cli/diagnostic-command');
+const { withTargetShopDefault } = require('../../../../../execution/target-shop-default');
+const { resolveTargetShop } = require('../../../../../execution/target-shop');
+const { inputIssue, parseIntegerOption, withInputScope } = require('../../../../../execution/error-details');
+const { validateCommandValue } = require('../../../../../execution/command-schema');
+const { parseDateTimeRange } = require('../../../../../execution/range');
+const { createShopQuery, failure, bindingPath } = require('../../../../../execution/shop-query');
+const { project } = require('./projection');
+const schema = require('./schema.json');
+
+const command = 'valuecard.transaction.list';
+const responseLimit = 10 * 1024 * 1024;
+const outputLimit = 5 * 1024 * 1024;
+
+function body(input) {
+  return { biz_type: input.bizType.toUpperCase(), begin_time: input.occurredAt.start.slice(0, 19),
+    end_time: input.occurredAt.end.slice(0, 19), page: input.pageNo, page_size: input.pageSize };
+}
+
+function buildInput(options, context) {
+  const scope = resolveTargetShop(options, context, command);
+  return withInputScope(scope, () => {
+    let occurredAt;
+    try {
+      occurredAt = parseDateTimeRange(options.occurredAt, { precision: 'seconds', requireBoth: true, strictOrder: true });
+    } catch {
+      throw inputIssue('/occurredAt', 'invalid_format', {
+        format: '北京时间 START..END，两端为有效日历时间 YYYY-MM-DD HH:mm:ss，可带零毫秒，开始须早于结束'
+      });
+    }
+    const input = { ...scope, bizType: options.bizType, occurredAt,
+      pageNo: parseIntegerOption(options.pageNo, schema, '/pageNo'),
+      pageSize: parseIntegerOption(options.pageSize, schema, '/pageSize'),
+      format: options.format, dryRun: options.dryRun === true };
+    validateCommandValue(schema, 'input', input);
+    if (input.pageNo * input.pageSize > 5000) {
+      throw inputIssue('/pageNo', 'constraint', { format: 'pageNo * pageSize <= 5000' }, ['/pageSize']);
+    }
+    return input;
+  });
+}
+
+async function execute(input) {
+  const scope = { kdtId: input.kdtId };
+  const read = await createShopQuery(scope, command, {
+    transportOptions: { maxResponseBytes: () => responseLimit, limitCategory: 'limit', limitStage: 'response-bytes', shopApp: false }
+  });
+  const response = await read(schema.api.path, body(input), 'transactions');
+  try {
+    const output = { data: project(response.data, input) };
+    validateCommandValue(schema, 'output', output);
+    return output;
+  } catch {
+    throw failure(command, 'protocol', 'transactions-model', scope, 'sent', response.facts);
+  }
+}
+
+function createCommand({ context } = {}) {
+  const leaf = new DiagnosticCommand('list', { path: command, schema, parameterCategory: 'parameter' })
+    .description('按一种业务类型和明确业务时间，读取一页储值交易流水及本金、赠送金和记录余额')
+    .allowExcessArguments(false)
+    .option('--kdt-id <id>', '目标店铺正安全整数；省略取上下文 shopId，非总部不可跨店')
+    .requiredOption('--biz-type <type>', '单个小写业务类型，完整字典见 schema；不接受 CSV 或 all')
+    .requiredOption('--occurred-at <START..END>', '北京时间 YYYY-MM-DD HH:mm:ss，两端必填且开始早于结束；仅接受零毫秒')
+    .option('--page-no <n>', '页码从 1 开始，pageNo * pageSize <= 5000', '1')
+    .option('--page-size <n>', '每页容量 1..50，默认 20；每次只读一页', '20')
+    .addOption(new Option('--format <format>', 'json 或 pretty，仅改变缩进').choices(['json', 'pretty']).default('json'))
+    .option('--dry-run', '本地脱敏请求预览，不读凭证、不联网')
+    .addHelpText('after', `
+业务类型：recharge、group_give_recharge、refund、recharge_refund、pay、card_account_adjustment_add、
+card_account_adjustment_subtract、card_balance_import_add、card_balance_import_subtract、recede_card、
+gift_card_active、recharge_bonus、refund_close_transfer_in、refund_close_transfer_out、combine_in、combine_out。
+输出 data.transactions 与 data.pagination，金额为人民币元两位字符串，时间为北京时间毫秒文本。
+billCardNo 不保证等于 card.cardNo；amount 不代表统一增减方向，reportedBalance 不保证交易前后时点。
+不按客户、卡号或订单筛选，不自动翻页或重试。最多一次同店绑定和一次流水请求。
+hasMore=null 表示总数未知；nextPageNo=null 不单独证明耗尽，达到窗口时缩小时间范围重新查询。
+不承诺稳定排序、跨页快照、全历史或自动余额对账；失败时不输出部分流水。
+产品支持范围由服务端决定：新储值商家可查全部卡交易，老储值商家仅支持礼品卡交易。
+示例：zan-saas valuecard transaction list --biz-type recharge --occurred-at "2026-11-01 00:00:00..2026-11-11 12:00:00" --kdt-id 63077 --dry-run
+`)
+    .action(async options => {
+      const input = buildInput(options, context);
+      let output;
+      if (input.dryRun) {
+        output = { command, kind: 'atomic', risk: 'read', target: { kdtId: input.kdtId }, requests: [
+          { method: 'POST', path: bindingPath, body: {} },
+          { method: 'POST', path: schema.api.path, body: body(input) }
+        ] };
+        validateCommandValue(schema, 'preview', output);
+      } else output = await execute(input);
+      const text = `${JSON.stringify(output, null, input.format === 'pretty' ? 2 : 0)}\n`;
+      if (Buffer.byteLength(text, 'utf8') > outputLimit) {
+        throw failure(command, 'limit', 'output-bytes', { kdtId: input.kdtId }, input.dryRun ? 'not_sent' : 'sent');
+      }
+      process.stdout.write(text);
+    });
+  const seen = new Set();
+  for (const option of leaf.options) {
+    leaf.on(`option:${option.name()}`, () => {
+      if (seen.has(option.long)) throw leaf.issue('constraint', option);
+      seen.add(option.long);
+    });
+  }
+  return leaf;
+}
+
+module.exports = { kind: 'atomic', risk: 'read', at: 'all', createCommand: withTargetShopDefault(createCommand) };

package/src/commands/native/valuecard/transaction/list/projection.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { object } = require('../../../../../execution/query-api');
+const { normalizeMoney } = require('../../../../../execution/money');
+const { fromBeijingSeconds } = require('../../../../../execution/beijing-date-time');
+
+function requiredText(value) {
+  if (typeof value !== 'string' || !value.trim() || /[\u0000-\u001f\u007f-\u009f]/u.test(value)) {
+    throw new TypeError('Invalid transaction text');
+  }
+  return value;
+}
+
+function money(value) {
+  if (!Number.isSafeInteger(value)) throw new TypeError('Invalid transaction money');
+  return normalizeMoney(value, { $comment: 'upstream-money:fen' });
+}
+
+function projectTransaction(item) {
+  if (!object(item)) throw new TypeError('Invalid transaction');
+  const transaction = {
+    transactionNo: requiredText(item.consumption_no), billCardNo: requiredText(item.group_no),
+    occurredAt: fromBeijingSeconds(item.consumption_time), bizType: requiredText(item.biz_type),
+    validity: requiredText(item.valid),
+    amount: { totalAmount: money(item.consumption_amount), principalAmount: money(item.principal_consumption_amount),
+      bonusAmount: money(item.bonus_consumption_amount) },
+    reportedBalance: { totalBalance: money(item.sum_dnom), principalBalance: money(item.principal_dnom),
+      bonusBalance: money(item.bonus_dnom) }
+  };
+  if (BigInt(item.sum_dnom) !== BigInt(item.principal_dnom) + BigInt(item.bonus_dnom)) {
+    throw new TypeError('Invalid reported balance');
+  }
+  if (Object.hasOwn(item, 'kdt_id')) {
+    if (!Number.isSafeInteger(item.kdt_id) || item.kdt_id < 1) throw new TypeError('Invalid record shop');
+    transaction.kdtId = String(item.kdt_id);
+  }
+  const optional = { mobile: 'mobile', tradeNo: 'trade_no', externalRequestNo: 'out_request_no',
+    remark: 'remark', externalRemark: 'out_remark', nickname: 'nick_name', acceptShopName: 'accept_shop_name' };
+  for (const [target, source] of Object.entries(optional)) {
+    if (!Object.hasOwn(item, source)) continue;
+    if (typeof item[source] !== 'string') throw new TypeError('Invalid optional transaction text');
+    transaction[target] = item[source];
+  }
+  return transaction;
+}
+
+function projectPagination(paginator, items, input) {
+  const invalid = () => new TypeError('Invalid transaction pagination');
+  if (!object(paginator) || !Array.isArray(items)) throw invalid();
+  const pageNo = paginator.page;
+  const pageSize = Object.hasOwn(paginator, 'page_size') ? paginator.page_size : input.pageSize;
+  const hasTotal = Object.hasOwn(paginator, 'total_count');
+  const total = hasTotal ? paginator.total_count : null;
+  if (hasTotal && (!Number.isSafeInteger(total) || total < 0)) throw invalid();
+  if (!Number.isSafeInteger(pageNo) || pageNo !== input.pageNo || pageNo < 1 ||
+      !Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 50 || pageNo * pageSize > 5000 ||
+      items.length > pageSize || (total !== null && items.length > total)) throw invalid();
+  const hasMore = total === null ? null : pageNo * pageSize < total;
+  const nextFits = (pageNo + 1) * pageSize <= 5000;
+  return { pageNo, pageSize, returned: items.length, ...(total === null ? {} : { total }), hasMore,
+    nextPageNo: hasMore === true && nextFits ? pageNo + 1 : null,
+    windowLimitReached: hasMore !== false && !nextFits };
+}
+
+function project(data, input) {
+  if (!object(data)) throw new TypeError('Invalid transaction data');
+  const pagination = projectPagination(data.paginator, data.items, input);
+  return { transactions: data.items.map(projectTransaction), pagination };
+}
+
+module.exports = { project, projectTransaction, projectPagination };