openyida 2026.7.19 → 2026.7.21

package/lib/core/yida-client.js

@@ -43,7 +43,9 @@ function isUsableAuthData(authData) {
   if (authData.auth_mode === 'token' || authData.authMode === 'token') {
     return true;
   }
-  return false;
+  const cookies = Array.isArray(authData.cookies) ? authData.cookies : [];
+  const csrfToken = authData.csrf_token || authData.csrfToken || authData._csrf_token;
+  return cookies.length > 0 && typeof csrfToken === 'string' && csrfToken.length > 0;
 }
 
 function createAuthRef(authData) {
@@ -53,7 +55,7 @@ function createAuthRef(authData) {
     : triggerLogin();
   const safeAuthData = loadedAuthData || {};
 
-  return {
+  const authRef = {
     baseUrl: resolveBaseUrl(safeAuthData),
     authData: safeAuthData,
     authMode: safeAuthData.auth_mode || safeAuthData.authMode || '',
@@ -61,6 +63,12 @@ function createAuthRef(authData) {
     corpId: safeAuthData.corp_id || '',
     userId: safeAuthData.user_id || '',
   };
+  if (Array.isArray(safeAuthData.cookies)) {
+    authRef.cookieData = safeAuthData;
+    authRef.cookies = safeAuthData.cookies;
+    authRef.csrfToken = safeAuthData.csrf_token || safeAuthData.csrfToken || safeAuthData._csrf_token || '';
+  }
+  return authRef;
 }
 
 function isTokenAuthRef(authRef) {
@@ -80,6 +88,22 @@ function isTokenAuthRef(authRef) {
   return authMode === 'token' || authSource === 'token';
 }
 
+function isCookieAuthRef(authRef) {
+  if (!authRef) {
+    return false;
+  }
+  const authData = authRef.authData || authRef.cookieData || {};
+  const authMode = authRef.authMode || authRef.auth_mode || authData.auth_mode || authData.authMode;
+  const authSource = authRef.authSource || authRef.auth_source || authData.auth_source || authData.authSource;
+  return (
+    authMode === 'env' ||
+    authMode === 'cookie' ||
+    authSource === 'env' ||
+    authSource === 'cookie' ||
+    Array.isArray(authRef.cookies)
+  );
+}
+
 function isAuthRefReady(authRef) {
   if (!authRef) {
     return false;
@@ -87,7 +111,14 @@ function isAuthRefReady(authRef) {
   if (isTokenAuthRef(authRef)) {
     return true;
   }
-  return false;
+  return (
+    isCookieAuthRef(authRef) &&
+    typeof authRef.baseUrl === 'string' &&
+    authRef.baseUrl.length > 0 &&
+    typeof authRef.csrfToken === 'string' &&
+    authRef.csrfToken.length > 0 &&
+    Array.isArray(authRef.cookies)
+  );
 }
 
 class YidaClient {
@@ -117,6 +148,20 @@ class YidaClient {
     );
   }
 
+  async getOnce(requestPath, queryParams, options) {
+    const ref = requireReadAuth(this.authRef);
+    const resolvedRequestPath = typeof requestPath === 'function'
+      ? requestPath(ref)
+      : requestPath;
+    const resolvedQueryParams = typeof queryParams === 'function'
+      ? queryParams(ref)
+      : queryParams;
+    if (options === undefined) {
+      return httpGet(ref.baseUrl, resolvedRequestPath, resolvedQueryParams || null, ref.cookies);
+    }
+    return httpGet(ref.baseUrl, resolvedRequestPath, resolvedQueryParams || null, ref.cookies, options);
+  }
+
   async postForm(requestPath, bodyParams, options) {
     return requestWithAutoLogin(
       (ref) => {
@@ -138,6 +183,23 @@ class YidaClient {
     );
   }
 
+  async postFormOnce(requestPath, bodyParams, options) {
+    const ref = requireOneShotAuth(this.authRef);
+    const resolvedRequestPath = typeof requestPath === 'function'
+      ? requestPath(ref)
+      : requestPath;
+    const resolvedBodyParams = typeof bodyParams === 'function'
+      ? bodyParams(ref)
+      : bodyParams;
+    const postData = typeof resolvedBodyParams === 'string'
+      ? resolvedBodyParams
+      : querystring.stringify(resolvedBodyParams || {});
+    if (options === undefined) {
+      return httpPost(ref.baseUrl, resolvedRequestPath, postData, ref.cookies);
+    }
+    return httpPost(ref.baseUrl, resolvedRequestPath, postData, ref.cookies, options);
+  }
+
   async postJson(requestPath, bodyParams, options) {
     return requestWithAutoLogin(
       (ref) => {
@@ -178,6 +240,44 @@ class YidaClient {
   }
 }
 
+function requireOneShotAuth(authRef) {
+  if (!authRef || typeof authRef.baseUrl !== 'string' || authRef.baseUrl.length === 0) {
+    const error = new Error('Schema write authentication is not ready.');
+    error.code = 'YIDA_WRITE_AUTH_NOT_READY';
+    throw error;
+  }
+  if (isTokenAuthRef(authRef)) {
+    return authRef;
+  }
+  if (
+    typeof authRef.csrfToken !== 'string' ||
+    authRef.csrfToken.length === 0 ||
+    !Array.isArray(authRef.cookies)
+  ) {
+    const error = new Error('Schema write authentication is not ready.');
+    error.code = 'YIDA_WRITE_AUTH_NOT_READY';
+    throw error;
+  }
+  return authRef;
+}
+
+function requireReadAuth(authRef) {
+  if (!authRef || typeof authRef.baseUrl !== 'string' || authRef.baseUrl.length === 0) {
+    const error = new Error('Yida read authentication is not ready.');
+    error.code = 'YIDA_READ_AUTH_NOT_READY';
+    throw error;
+  }
+  if (isTokenAuthRef(authRef)) {
+    return authRef;
+  }
+  if (!Array.isArray(authRef.cookies)) {
+    const error = new Error('Yida read authentication is not ready.');
+    error.code = 'YIDA_READ_AUTH_NOT_READY';
+    throw error;
+  }
+  return authRef;
+}
+
 function createYidaClient(options = {}) {
   return new YidaClient(options);
 }
@@ -188,6 +288,7 @@ module.exports = {
   createAuthRef,
   createYidaClient,
   isAuthRefReady,
+  isCookieAuthRef,
   isTokenAuthRef,
   unwrapYidaResponse,
 };

package/lib/formula/evaluate.js

@@ -3,6 +3,11 @@
 const fs = require('fs');
 const { throwCommandError, throwUsage } = require('../core/command-errors');
 const path = require('path');
+const {
+  normalizeFormulaFieldRefs,
+  normalizeSubtableFieldId,
+  stripSubtableFieldPrefix,
+} = require('./field-refs');
 
 const KNOWN_FUNCTIONS = new Set([
   'ABS',
@@ -49,12 +54,6 @@ const KNOWN_FUNCTIONS = new Set([
   'YEAR',
 ]);
 
-// Subtable child fields are stored flat in the schema (get-schema / save never
-// emit a "tableField_xxx.xxx" form), and Yida formulas reference them by their
-// plain fieldId. A "tableField_xxx." prefix inside #{...} is therefore always
-// an invalid reference that the web platform cannot resolve.
-const SUBTABLE_FIELD_PREFIX_PATTERN = /^tableField_[A-Za-z0-9]+\./;
-
 const CHINESE_PUNCTUATION = {
   '，': ',',
   '；': ',',
@@ -164,64 +163,6 @@ function collectSchemaFieldIds(value) {
   return fieldIds;
 }
 
-// Rewrite every `#{tableField_xxx.field}` reference inside a string to the
-// canonical `#{field}` form. Returns the corrected string plus how many refs
-// were fixed. Only the exact `#{tableField_<alnum>.<rest>}` shape is touched,
-// so unrelated text (e.g. a JS regex like `#{1,3}`) is left untouched.
-function stripSubtableFieldPrefix(str) {
-  if (typeof str !== 'string' || str.indexOf('#{') === -1) {
-    return { value: str, count: 0 };
-  }
-
-  let count = 0;
-  const value = str.replace(/#\{([^}]*)\}/g, (whole, inner) => {
-    const trimmed = inner.trim();
-    if (SUBTABLE_FIELD_PREFIX_PATTERN.test(trimmed)) {
-      count += 1;
-      return `#{${trimmed.replace(SUBTABLE_FIELD_PREFIX_PATTERN, '')}}`;
-    }
-    return whole;
-  });
-
-  return { value, count };
-}
-
-// Recursively walk any schema node (object/array) and normalize subtable
-// prefixes in every string value in place. Returns the total number of refs
-// fixed. Covers formula, complexValue.formula, expression, linkage, and any
-// other string-valued property uniformly.
-function normalizeFormulaFieldRefs(node) {
-  let total = 0;
-
-  function visit(parent, key) {
-    const current = parent[key];
-    if (typeof current === 'string') {
-      const { value, count } = stripSubtableFieldPrefix(current);
-      if (count > 0) {
-        parent[key] = value;
-        total += count;
-      }
-      return;
-    }
-    if (Array.isArray(current)) {
-      for (let i = 0; i < current.length; i++) {
-        visit(current, i);
-      }
-      return;
-    }
-    if (current && typeof current === 'object') {
-      for (const childKey of Object.keys(current)) {
-        visit(current, childKey);
-      }
-    }
-  }
-
-  if (node && typeof node === 'object') {
-    visit({ root: node }, 'root');
-  }
-  return total;
-}
-
 function scanOutsideStrings(formula, callback) {
   let quote = '';
   let escaped = false;
@@ -355,8 +296,9 @@ function collectFieldRefs(formula, diagnostics) {
           { fieldId, index }
         ));
       }
-      if (SUBTABLE_FIELD_PREFIX_PATTERN.test(fieldId)) {
-        const suggestion = fieldId.replace(SUBTABLE_FIELD_PREFIX_PATTERN, '');
+      const normalizedFieldId = normalizeSubtableFieldId(fieldId);
+      if (normalizedFieldId.changed) {
+        const suggestion = normalizedFieldId.value;
         diagnostics.push(createDiagnostic(
           'error',
           'field_ref_subtable_prefix',

package/lib/formula/field-refs.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// Subtable child fields are stored flat in the schema (get-schema / save never
+// emit a "tableField_xxx.xxx" form), and Yida formulas reference them by their
+// plain fieldId. A "tableField_xxx." prefix inside #{...} is therefore always
+// an invalid reference that the web platform cannot resolve.
+const SUBTABLE_FIELD_PREFIX_PATTERN = /^tableField_[A-Za-z0-9]+\./;
+
+function normalizeSubtableFieldId(fieldId) {
+  const value = String(fieldId || '');
+  if (!SUBTABLE_FIELD_PREFIX_PATTERN.test(value)) {
+    return { value, changed: false };
+  }
+  return {
+    value: value.replace(SUBTABLE_FIELD_PREFIX_PATTERN, ''),
+    changed: true,
+  };
+}
+
+// Rewrite every `#{tableField_xxx.field}` reference inside a string to the
+// canonical `#{field}` form. Returns the corrected string plus how many refs
+// were fixed. Only the exact `#{tableField_<alnum>.<rest>}` shape is touched,
+// so unrelated text (e.g. a JS regex like `#{1,3}`) is left untouched.
+function stripSubtableFieldPrefix(str) {
+  if (typeof str !== 'string' || str.indexOf('#{') === -1) {
+    return { value: str, count: 0 };
+  }
+
+  let count = 0;
+  const value = str.replace(/#\{([^}]*)\}/g, (whole, inner) => {
+    const trimmed = inner.trim();
+    const normalized = normalizeSubtableFieldId(trimmed);
+    if (normalized.changed) {
+      count += 1;
+      return `#{${normalized.value}}`;
+    }
+    return whole;
+  });
+
+  return { value, count };
+}
+
+// Recursively walk any schema node (object/array) and normalize subtable
+// prefixes in every string value in place. Returns the total number of refs
+// fixed. Covers formula, complexValue.formula, expression, linkage, and any
+// other string-valued property uniformly.
+function normalizeFormulaFieldRefs(node) {
+  let total = 0;
+
+  function visit(parent, key) {
+    const current = parent[key];
+    if (typeof current === 'string') {
+      const { value, count } = stripSubtableFieldPrefix(current);
+      if (count > 0) {
+        parent[key] = value;
+        total += count;
+      }
+      return;
+    }
+    if (Array.isArray(current)) {
+      for (let i = 0; i < current.length; i++) {
+        visit(current, i);
+      }
+      return;
+    }
+    if (current && typeof current === 'object') {
+      for (const childKey of Object.keys(current)) {
+        visit(current, childKey);
+      }
+    }
+  }
+
+  if (node && typeof node === 'object') {
+    visit({ root: node }, 'root');
+  }
+  return total;
+}
+
+module.exports = {
+  normalizeFormulaFieldRefs,
+  normalizeSubtableFieldId,
+  stripSubtableFieldPrefix,
+};