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

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

@@ -0,0 +1,183 @@
+'use strict';
+
+const { object } = require('../../../../execution/query-api');
+const { normalizeMoney } = require('../../../../execution/money');
+const { apiDateTime, formatDateTime, parseDateTime } = require('../../../../execution/datetime');
+
+function id(value, allowZero = false) {
+  if (typeof value === 'number') {
+    if (!Number.isSafeInteger(value)) throw new Error('unsafe id');
+    value = String(value);
+  }
+  if (typeof value !== 'string' || !/^\d+$/.test(value) || (!allowZero && !/[1-9]/.test(value))) {
+    throw new Error('invalid id');
+  }
+  return value;
+}
+
+function money(value, signed = false) {
+  if (typeof value !== 'string' || !(signed ? /^-?\d+(?:\.\d+)?$/ : /^\d+(?:\.\d+)?$/).test(value)) {
+    throw new Error('invalid yuan amount');
+  }
+  return normalizeMoney(value, { $comment: 'upstream-money:yuan' });
+}
+
+function text(value, nonempty = false) {
+  if (typeof value !== 'string' || (nonempty && !value.trim())) throw new Error('invalid text');
+  return value;
+}
+
+function integer(value, nonnegative = false) {
+  if (!Number.isSafeInteger(value) || (nonnegative && value < 0)) throw new Error('invalid integer');
+  return value;
+}
+
+function boolean(value) {
+  if (typeof value !== 'boolean') throw new Error('invalid boolean');
+  return value;
+}
+
+function time(value, empty = false) {
+  if (empty && value === '') return value;
+  apiDateTime(value);
+  return formatDateTime(parseDateTime(value));
+}
+
+function project(source, fields, required = []) {
+  if (!object(source)) throw new Error('missing object');
+  const result = {};
+  for (const [target, [field, convert]] of Object.entries(fields)) {
+    if (Object.hasOwn(source, field)) result[target] = convert(source[field]);
+    else if (required.includes(target)) throw new Error('missing field');
+  }
+  if (!Object.keys(result).length) throw new Error('empty selected module');
+  return result;
+}
+
+function array(value, convert) {
+  if (!Array.isArray(value)) throw new Error('missing array');
+  return value.map(convert);
+}
+
+const nonemptyText = value => text(value, true);
+const zeroId = value => id(value, true);
+const nonnegative = value => integer(value, true);
+const deliveryTypes = Object.freeze({ 0: 'EXPRESS', 1: 'SELF_FETCH', 2: 'LOCAL_DELIVERY', 9: 'VIRTUAL' });
+
+function order(source) {
+  const result = project(source, {
+    orderNo: ['tid', nonemptyText], kdtId: ['node_kdt_id', id], rootKdtId: ['root_kdt_id', id],
+    status: ['status', nonemptyText], statusText: ['status_str', text], type: ['type', integer],
+    createdAt: ['created', time], updatedAt: ['update_time', time], shopName: ['shop_name', text]
+  }, ['orderNo', 'kdtId', 'status', 'type', 'createdAt']);
+  if (Object.hasOwn(source, 'pay_time') && source.pay_time !== '' && source.pay_time !== null) {
+    result.paidAt = time(source.pay_time);
+  }
+  if (Object.hasOwn(source, 'order_tags')) {
+    if (!object(source.order_tags)) throw new Error('invalid order tags');
+    if (Object.hasOwn(source.order_tags, 'is_payed')) result.isPaid = boolean(source.order_tags.is_payed);
+  }
+  return result;
+}
+
+function items(source) {
+  return array(source, entry => {
+    if (!object(entry)) throw new Error('missing item');
+    const normalized = { ...entry };
+    for (const name of ['unified_item_id', 'unified_sku_id']) {
+      if (normalized[name] === '') delete normalized[name];
+    }
+    return project(normalized, {
+    oid: ['oid', nonemptyText], title: ['title', text], quantity: ['num', nonnegative],
+    item_id: ['unified_item_id', id], sku_id: ['unified_sku_id', zeroId],
+    channel_item_id: ['item_id', id], channel_sku_id: ['sku_id', zeroId],
+    unitPrice: ['price', money], payment: ['payment', money],
+    isPresent: ['is_present', boolean], isCombo: ['is_combo', boolean]
+    }, ['oid', 'title', 'quantity']);
+  });
+}
+
+function payment(source) {
+  return project(source, {
+    totalFee: ['total_fee', money], postFee: ['post_fee', money],
+    payment: ['payment', money], realPayment: ['real_payment', money]
+  }, ['totalFee', 'postFee', 'payment', 'realPayment']);
+}
+
+function listPayment(source) {
+  return project(source, {
+    totalFee: ['total_fee', money], postFee: ['post_fee', money],
+    payment: ['payment', money]
+  }, ['totalFee', 'postFee', 'payment']);
+}
+
+function listExtension(name, full) {
+  switch (name) {
+    case 'buyer': return project(full.buyer_info, { yzOpenId: ['yz_open_id', text] });
+    case 'address': return project(full.address_info, {
+      receiverName: ['receiver_name', text], receiverPhone: ['receiver_tel', text],
+      province: ['delivery_province', text], city: ['delivery_city', text],
+      district: ['delivery_district', text], address: ['delivery_address', text],
+      postalCode: ['delivery_postal_code', text]
+    });
+    case 'remark': return project(full.remark_info, {
+      buyerMessage: ['buyer_message', text], tradeMemo: ['trade_memo', text]
+    });
+    case 'source': return project(full.source_info, {
+      isOfflineOrder: ['is_offline_order', boolean], bookKey: ['book_key', text]
+    });
+    case 'aftersale': return project(full.order_info,
+      { refundState: ['refund_state', integer] }, ['refundState']);
+    case 'fulfillment': return project(full.order_info, {
+      deliveryType: ['express_type', value => {
+        integer(value);
+        if (!Object.hasOwn(deliveryTypes, value)) throw new Error('unknown delivery type');
+        return deliveryTypes[value];
+      }]
+    }, ['deliveryType']);
+    default: throw new Error('unknown module');
+  }
+}
+
+function extension(name, data, full) {
+  switch (name) {
+    case 'buyer': return project(full.buyer_info, { yzOpenId: ['yz_open_id', text] });
+    case 'address': return project(full.address_info, {
+      receiverName: ['receiver_name', text], receiverPhone: ['receiver_tel', text],
+      province: ['delivery_province', text], city: ['delivery_city', text],
+      district: ['delivery_district', text], address: ['delivery_address', text],
+      postalCode: ['delivery_postal_code', text]
+    });
+    case 'remark': return project(full.remark_info, {
+      buyerMessage: ['buyer_message', text], tradeMemo: ['trade_memo', text]
+    });
+    case 'source': return project(full.source_info, {
+      isOfflineOrder: ['is_offline_order', boolean], bookKey: ['book_key', text]
+    });
+    case 'promotion': return project(data.order_promotion, {
+      itemDiscountFee: ['item_discount_fee', money], orderDiscountFee: ['order_discount_fee', money],
+      adjustFee: ['adjust_fee', value => money(value, true)]
+    }, ['itemDiscountFee', 'orderDiscountFee', 'adjustFee']);
+    case 'fulfillment': return project(full.order_info, {
+      deliveryType: ['express_type', value => {
+        integer(value);
+        if (!Object.hasOwn(deliveryTypes, value)) throw new Error('unknown delivery type');
+        return deliveryTypes[value];
+      }], consignTime: ['consign_time', value => time(value, true)]
+    }, ['deliveryType']);
+    case 'aftersale': return {
+      ...project(full.order_info, { refundState: ['refund_state', integer] }, ['refundState']),
+      cases: array(data.refund_order, entry => project(entry, {
+        caseId: ['refund_id', nonemptyText], type: ['refund_type', integer], state: ['refund_state', integer],
+        refundFee: ['refund_fee', money], appliedAt: ['refund_time', time],
+        oids: ['oids', value => array(value, reference => {
+          if (!object(reference)) throw new Error('invalid oid reference');
+          return nonemptyText(reference.oid);
+        })]
+      }, ['caseId', 'type', 'state']))
+    };
+    default: throw new Error('unknown module');
+  }
+}
+
+module.exports = { id, money, text, integer, time, order, items, payment, listPayment, extension, listExtension };

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

@@ -0,0 +1,84 @@
+'use strict';
+
+const { resolveTargetShop } = require('../../../../execution/target-shop');
+const { createShopQuery, bindingPath, failure } = require('../../../../execution/shop-query');
+const { parseIncludeModules } = require('../../../../execution/command-io');
+const { copyErrorDetails } = require('../../../../execution/error-details');
+
+const RESPONSE_LIMIT = 10 * 1024 * 1024;
+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' ?
+    '主订单请求尚未发送。核对原凭证绑定店铺与显式目标，不自动重试、切店或换身份。' :
+    category === 'limit' ? '本次结果超出字节限制，未输出部分订单；停止并核对原范围，不截断或自动重试。' :
+      '核对原店铺、订单号、上下文与服务端授权；结构不符时停止，不自动重试、解密或换身份。';
+  return error;
+}
+
+function adaptError(error, command, scope) {
+  if (!error.cliDetails) return error;
+  const details = error.cliDetails;
+  const category = details.category === 'parameter' ? 'validation' : details.category;
+  const stage = ['scope', 'validation'].includes(details.stage) ? 'input' : details.stage;
+  const adapted = reject(command, category, stage, scope, details.requestState);
+  adapted.cliDetails = copyErrorDetails(details, {
+    category, stage, command, targetScope: scope, nextStep: adapted.cliDetails.nextStep
+  });
+  if (error.diagnosticReason) adapted.diagnosticReason = error.diagnosticReason;
+  if (error.issues) adapted.issues = error.issues;
+  return adapted;
+}
+
+function targetScope(options, context, command) {
+  try {
+    const scope = resolveTargetShop(options, context, command);
+    return Object.freeze({ kdtId: String(scope.kdtId) });
+  } catch (error) {
+    const scope = error.cliDetails?.targetScope?.kdtId;
+    throw adaptError(error, command, scope === undefined ? {} : { kdtId: String(scope) });
+  }
+}
+
+function includes(value, allowed, command, scope) {
+  if (value !== undefined && (typeof value !== 'string' || value.split(',').some(entry => !entry.trim()))) {
+    throw reject(command, 'validation', 'input', scope);
+  }
+  try { return [...parseIncludeModules(value, allowed)]; }
+  catch { throw reject(command, 'validation', 'input', scope); }
+}
+
+async function createOrderQuery(scope, command, { responseLimit = RESPONSE_LIMIT, onRequest,
+  bounded = false, shopApp } = {}) {
+  let responseBytes = 0;
+  function onResponse(response, path) {
+    responseBytes += response.responseBytes;
+    if (responseBytes > responseLimit) {
+      throw reject(command, 'limit', path === bindingPath ? 'shop-binding' : 'order', 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 }
+    });
+    return async (path, body, stage = 'order') => {
+      try { return await read(path, body, stage); }
+      catch (error) { throw adaptError(error, command, scope); }
+    };
+  } catch (error) { throw adaptError(error, command, scope); }
+}
+
+function serialize(output, format, command, scope, outputLimit = OUTPUT_LIMIT) {
+  const json = JSON.stringify(output, null, format === 'pretty' ? 2 : 0);
+  if (Buffer.byteLength(`${json}\n`, 'utf8') > outputLimit) {
+    throw reject(command, 'limit', 'output-model', scope, 'sent');
+  }
+  return json;
+}
+
+module.exports = {
+  bindingPath, reject, targetScope, includes, createOrderQuery, serialize, RESPONSE_LIMIT, OUTPUT_LIMIT
+};

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

@@ -0,0 +1,112 @@
+'use strict';
+
+const { readTotal } = require('../../../../execution/list-total');
+
+const { apiDateTime } = require('../../../../execution/datetime');
+const { object } = require('../../../../execution/query-api');
+const { createOrderQuery, reject } = require('./query');
+const projection = require('./projection');
+
+const listPath = 'youzan.trades.sold.get/4.0.4';
+const lifecycleFields = [['created', 'created'], ['updated', 'update'], ['paid', 'pay'], ['succeeded', 'success']];
+const filterOptions = Object.freeze([
+  ['orderNo', 'orderNo', 'tid'], ['yzOpenId', 'yzOpenId', 'yz_open_id'],
+  ['status', 'status', 'status'], ['type', 'type', 'type'],
+  ['item_id', 'itemId', 'goods_id'], ['itemTitle', 'itemTitle', 'goods_title'],
+  ['receiverPhone', 'receiverPhone', 'receiver_phone'],
+  ['receiverName', 'receiverName', 'receiver_name'],
+  ['deliveryType', 'deliveryType', 'express_type'], ['keyword', 'keyword', 'keywords']
+]);
+
+function toRequestBody(input) {
+  const body = {
+    node_kdt_id: Number(input.scope.kdtId),
+    page_no: input.pagination.pageNo,
+    page_size: input.pagination.pageSize
+  };
+  for (const [name, , upstream] of filterOptions) {
+    if (input.filters[name] === undefined) continue;
+    body[upstream] = name === 'item_id' ? Number(input.filters[name]) : input.filters[name];
+  }
+  for (const [name, upstream] of lifecycleFields) {
+    if (!input.range[name]) continue;
+    body[`start_${upstream}`] = apiDateTime(input.range[name].start);
+    body[`end_${upstream}`] = apiDateTime(input.range[name].end);
+  }
+  if (input.range.delivery) {
+    const deliveryTime = value => {
+      const formatted = apiDateTime(value);
+      return `${formatted.slice(0, 10)}-${formatted.slice(11).replaceAll(':', '-')}`;
+    };
+    body.delivery_start_time = deliveryTime(input.range.delivery.start);
+    body.delivery_end_time = deliveryTime(input.range.delivery.end);
+  }
+  return body;
+}
+
+function toPreviewBody(input) {
+  const body = toRequestBody(input);
+  for (const name of ['receiver_phone', 'receiver_name', 'keywords']) {
+    if (Object.hasOwn(body, name)) body[name] = '***';
+  }
+  return body;
+}
+
+function adaptPage(data, input, context, facts, command = 'order.order.list') {
+  try {
+    if (!object(data) || !Array.isArray(data.full_order_info_list) ||
+        data.full_order_info_list.length > input.pagination.pageSize) throw new Error('invalid page');
+    const total = readTotal(data, 'total_results');
+    if (command === 'order.order.scan' && total === null) throw new Error('missing scan total');
+    const start = (input.pagination.pageNo - 1) * input.pagination.pageSize;
+    if (total !== null && ((data.full_order_info_list.length > 0 && start + data.full_order_info_list.length > total) ||
+        (total > 0 && start < total && data.full_order_info_list.length === 0))) {
+      throw new Error('contradictory page');
+    }
+    const orders = data.full_order_info_list.map(entry => {
+      if (!object(entry) || !object(entry.full_order_info)) throw new Error('missing order');
+      const full = entry.full_order_info;
+      const order = projection.order(full.order_info);
+      if (order.kdtId !== input.scope.kdtId ||
+          (Object.hasOwn(order, 'rootKdtId') && order.rootKdtId !== context.hq)) {
+        throw reject(command, 'scope_unresolved', 'orders', input.scope, 'sent', facts);
+      }
+      const row = { order };
+      for (const name of input.include) {
+        if (name === 'items') row.items = projection.items(full.orders);
+        else if (name === 'payment') row.payment = projection.listPayment(full.pay_info);
+        else row[name] = projection.listExtension(name, full);
+      }
+      return row;
+    });
+    const output = { data: { orders, pagination: {
+      pageNo: input.pagination.pageNo, pageSize: input.pagination.pageSize,
+      returned: orders.length, hasMore: total === null ? null : start + input.pagination.pageSize < total
+    } } };
+    if (command === 'order.order.list') {
+      const pagination = output.data.pagination;
+      if (total !== null) pagination.total = total;
+      pagination.nextPageNo = pagination.hasMore === true && pagination.pageNo < 100 ? pagination.pageNo + 1 : null;
+      pagination.windowLimitReached = pagination.hasMore !== false && pagination.pageNo >= 100;
+    }
+    return output;
+  } catch (error) {
+    if (error.cliDetails) throw error;
+    throw reject(command, 'protocol', 'output-model', input.scope, 'sent', facts);
+  }
+}
+
+async function createOrderPageReader(scope, context, command, options) {
+  const read = await createOrderQuery(scope, command, options);
+  return async input => {
+    const { pageNo, pageSize } = input.pagination;
+    if (input.scope.kdtId !== scope.kdtId || !Number.isSafeInteger(pageNo) || pageNo < 1 || pageNo > 100 ||
+        !Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+      throw reject(command, 'validation', 'input', scope);
+    }
+    const { data, facts } = await read(listPath, toRequestBody(input), 'orders');
+    return { output: adaptPage(data, input, context, facts, command), total: data.total_results };
+  };
+}
+
+module.exports = { listPath, toRequestBody, toPreviewBody, adaptPage, createOrderPageReader, filterOptions };

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

@@ -0,0 +1,42 @@
+{
+  "schemaVersion": 3,
+  "domain": "org",
+  "businessCommands": [
+    {
+      "path": "org.staff.get",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "shop",
+      "module": "org/staff/get/command.js",
+      "fingerprint": "0e6c6fd91988b916f4d5690677c712059ec65f7d6ce003eed7d7192ce61f6d96"
+    },
+    {
+      "path": "org.staff-role.get",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "shop",
+      "module": "org/staff-role/get/command.js",
+      "fingerprint": "cfa719f5122449c0a57e5db59bfd760d17d717f95088c9d886586b53304a7041"
+    },
+    {
+      "path": "org.unit.get",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "all",
+      "module": "org/unit/get/command.js",
+      "fingerprint": "d11775de4f1c6d7500310c3f8b373bee7e829ab5afe586ae617037571b4d0597"
+    },
+    {
+      "path": "org.unit.list",
+      "kind": "atomic",
+      "risk": "read",
+      "availability": "available",
+      "at": "hq",
+      "module": "org/unit/list/command.js",
+      "fingerprint": "6bee5cdcffb1893319280f50f9b49e752d16dbadcae5413bce3bbfcf476a9fc6"
+    }
+  ]
+}

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

@@ -0,0 +1,3 @@
+{
+  "description": "组织：组织资料、员工与角色关联"
+}

package/src/commands/native/org/shared/single-staff.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const { resolveTargetShop } = require('../../../../execution/target-shop');
+const { readContext } = require('../../../../identity/context');
+const { validateCommandValue } = require('../../../../execution/command-schema');
+const { inputIssue, constraints, modelAt } = require('../../../../execution/error-details');
+const { object } = require('../../../../execution/query-api');
+const { createBoundShopQuery, failure, bindingPath } = require('../../../../execution/shop-query');
+
+const staffPath = 'youzan.shop.single.staff.get/1.0.0';
+
+function staffInput(options, context, command, schema) {
+  let scope;
+  try {
+    scope = resolveTargetShop(options, context, command);
+  } catch (error) {
+    if (error.cliDetails?.stage === 'validation') error.cliDetails.stage = 'input';
+    throw error;
+  }
+  const state = readContext(context);
+  if (state.status === 'ready' && state.context.orgType !== 'shop') {
+    throw failure(command, 'permission', 'context', scope);
+  }
+  try {
+    if (typeof options.mobile !== 'string' || /[\x00-\x1f\x7f-\x9f]/.test(options.mobile)) {
+      throw inputIssue('/mobile', typeof options.mobile === 'string' ? 'invalid_format' : 'invalid_type',
+        constraints(modelAt(schema, 'input', '/mobile')));
+    }
+    const input = { ...scope, mobile: options.mobile.replace(/^ +| +$/g, '') };
+    if (schema.errors?.diagnosticsVersion === 2 && !/^1[0-9]{10}$/.test(input.mobile)) {
+      throw inputIssue('/mobile', 'invalid_format', {
+        ...constraints(modelAt(schema, 'input', '/mobile')),
+        format: '员工登录账号的11位手机号，1开头且只含数字'
+      });
+    }
+    validateCommandValue(schema, 'input', input);
+    return input;
+  } catch (error) {
+    if (schema.errors?.diagnosticsVersion === 2 && error.section === 'input') {
+      error.inputScope = scope;
+      throw error;
+    }
+    throw failure(command, 'parameter', 'input', scope);
+  }
+}
+
+function staffPreview(input) {
+  return { scope: { kdtId: input.kdtId }, requests: [
+    { stage: 'shop-binding', method: 'POST', path: bindingPath, body: {} },
+    { stage: 'staff', method: 'POST', path: staffPath, body: { account: '***' } }
+  ] };
+}
+
+async function readStaffModel(input, command, selectStaff, options) {
+  const scope = { kdtId: input.kdtId };
+  const { read, binding } = await createBoundShopQuery(scope, command, 'shop-binding', options);
+  if (!Number.isSafeInteger(binding.data.role) || binding.data.role < 0) {
+    throw failure(command, 'protocol', 'shop-binding', scope, 'sent', binding.facts);
+  }
+  if (binding.data.role !== 0) {
+    throw failure(command, 'permission', 'shop-binding', scope, 'sent', binding.facts);
+  }
+  const response = await read(staffPath, { account: input.mobile }, 'staff');
+  const staff = selectStaff(response.envelope);
+  const reject = (category, reason) => {
+    const error = failure(command, category, 'staff-model', scope, 'sent', response.facts);
+    error.diagnosticReason = reason;
+    return error;
+  };
+  if (!object(staff)) throw reject('protocol', 'staff_object_invalid');
+  if (!Number.isSafeInteger(staff.kdt_id) || staff.kdt_id < 1) {
+    throw reject('protocol', 'staff_shop_id_invalid');
+  }
+  if (staff.kdt_id !== input.kdtId) {
+    throw reject('scope_unresolved', 'staff_shop_mismatch');
+  }
+  return { staff, facts: response.facts, read };
+}
+
+async function readSingleShopStaff(input, command) {
+  return readStaffModel(input, command, envelope => envelope.data);
+}
+
+async function readSingleShopStaffIdentity(input, command, options) {
+  try {
+    return await readStaffModel(input, command, envelope => envelope.data, options);
+  } catch (error) {
+    if (error.cliDetails?.stage === 'staff' && error.cliDetails.category === 'business_rejected' &&
+        [error.cliDetails.businessCode, error.cliDetails.gatewayCode].some(code => String(code) === '232500001')) {
+      error.cliDetails.category = 'not_found';
+      error.message = '查询失败：not_found（staff）';
+    }
+    throw error;
+  }
+}
+
+function staffRoles(staff, command, facts) {
+  const reject = () => failure(command, 'protocol', 'staff-roles', { kdtId: staff.kdt_id }, 'sent', facts);
+  if (!Array.isArray(staff.roles)) throw reject();
+  return staff.roles.map(role => {
+    if (!object(role) || !Number.isSafeInteger(role.role_id) || role.role_id < 1 ||
+        typeof role.name !== 'string') throw reject();
+    return { roleId: role.role_id, name: role.name };
+  });
+}
+
+function redactStaffDiagnostics(error, mobile) {
+  for (const field of ['businessCode', 'gatewayCode', 'trace_id', 'request_id']) {
+    if (String(error.cliDetails?.[field]).includes(mobile)) delete error.cliDetails[field];
+  }
+  return error;
+}
+
+module.exports = { staffPath, staffInput, staffPreview, readSingleShopStaff, readSingleShopStaffIdentity,
+  staffRoles, redactStaffDiagnostics };