@ctil/gql 1.0.20 → 1.0.21

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
 // src/core/core.ts
 import { GraphQLClient } from "graphql-request";
 
@@ -847,7 +851,7 @@ function setDeviceIdToIndexedDB(id) {
 async function getBrowserDeviceInfo() {
   let deviceId;
   try {
-    const { load } = await import("./fp.esm-VY6KF7TP.js");
+    const { load } = await import("./fp.esm-QIG5OYFT.js");
     const fp = await load();
     const result = await fp.get();
     deviceId = result.visitorId;
@@ -897,6 +901,40 @@ async function execute(payload) {
   return client2.request(payload.query, payload.variables);
 }
 
+// src/builders/index.ts
+var builders_exports = {};
+__export(builders_exports, {
+  buildCommonResultSelection: () => buildCommonResultSelection,
+  buildDataValue: () => buildDataValue,
+  buildFields: () => buildFields,
+  buildGraphQLGetFilePreview: () => buildGraphQLGetFilePreview,
+  buildGraphQLMutationBatchInsert: () => buildGraphQLMutationBatchInsert,
+  buildGraphQLMutationBatchUpdate: () => buildGraphQLMutationBatchUpdate,
+  buildGraphQLMutationDelete: () => buildGraphQLMutationDelete,
+  buildGraphQLMutationDeleteById: () => buildGraphQLMutationDeleteById,
+  buildGraphQLMutationInsertOne: () => buildGraphQLMutationInsertOne,
+  buildGraphQLMutationLogin: () => buildGraphQLMutationLogin,
+  buildGraphQLMutationLogout: () => buildGraphQLMutationLogout,
+  buildGraphQLMutationLogoutAllDevices: () => buildGraphQLMutationLogoutAllDevices,
+  buildGraphQLMutationLogoutDevice: () => buildGraphQLMutationLogoutDevice,
+  buildGraphQLMutationRefreshToken: () => buildGraphQLMutationRefreshToken,
+  buildGraphQLMutationRegisterUser: () => buildGraphQLMutationRegisterUser,
+  buildGraphQLMutationSendCode: () => buildGraphQLMutationSendCode,
+  buildGraphQLMutationUpdate: () => buildGraphQLMutationUpdate,
+  buildGraphQLMutationUpdateByPk: () => buildGraphQLMutationUpdateByPk,
+  buildGraphQLMutationVerifyCode: () => buildGraphQLMutationVerifyCode,
+  buildGraphQLQueryAggregate: () => buildGraphQLQueryAggregate,
+  buildGraphQLQueryByIdFixed: () => buildGraphQLQueryByIdFixed,
+  buildGraphQLQueryList: () => buildGraphQLQueryList,
+  buildGraphQLQueryPageList: () => buildGraphQLQueryPageList,
+  buildGraphQLUploadPresignedUrl: () => buildGraphQLUploadPresignedUrl,
+  buildMutationFields: () => buildMutationFields,
+  buildWhere: () => buildWhere,
+  formatGraphQLValue: () => formatGraphQLValue,
+  generateOperationName: () => generateOperationName,
+  toPascalCase: () => toPascalCase
+});
+
 // src/builders/baseType.ts
 function buildWhere(where) {
   if (!where) return "";
@@ -906,18 +944,27 @@ function buildWhere(where) {
     if (key === "_and" || key === "_or") {
       const sub = value.map((w) => `{ ${buildWhere(w)} }`).filter(Boolean).join(", ");
       if (sub) parts.push(`${key}: [${sub}]`);
-    } else if (key === "_not") {
+      continue;
+    }
+    if (key === "_not") {
       const sub = buildWhere(value);
       if (sub) parts.push(`${key}: { ${sub} }`);
-    } else if (typeof value === "object" && value !== null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      const list = value.map((v) => JSON.stringify(v)).join(", ");
+      parts.push(`${key}: [${list}]`);
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
       const sub = buildWhere(value);
-      parts.push(`${key}: { ${sub} }`);
+      if (sub) parts.push(`${key}: { ${sub} }`);
+      continue;
+    }
+    if (typeof value === "string" && value.startsWith("$")) {
+      parts.push(`${key}: ${value}`);
     } else {
-      if (typeof value === "string" && value.startsWith("$")) {
-        parts.push(`${key}: ${value}`);
-      } else {
-        parts.push(`${key}: ${JSON.stringify(value)}`);
-      }
+      parts.push(`${key}: ${JSON.stringify(value)}`);
     }
   }
   return parts.join(", ");
@@ -983,6 +1030,24 @@ function formatGraphQLValue(value) {
   }
   return JSON.stringify(value);
 }
+function generateOperationName(entityName, original) {
+  const lower = original.toLowerCase();
+  const e = entityName.toLowerCase();
+  if (original.startsWith("gql_")) {
+    if (lower.endsWith("pagelist")) return `get${entityName}PageList`;
+    if (lower.endsWith("querylist")) return `${e.toLowerCase()}s`;
+    if (lower.endsWith("getbyid")) return `${e.toLowerCase()}_by_pk`;
+    if (lower.endsWith("aggregate")) return `${e.toLowerCase()}_aggregateount`;
+    if (lower.endsWith("insertone")) return `insert_${e.toLowerCase()}_one`;
+    if (lower.endsWith("batchinsert")) return `insert_${e.toLowerCase()}s`;
+    if (lower.endsWith("batchupdate")) return `update_${e.toLowerCase()}_many`;
+    if (lower.endsWith("updatebypk")) return `update_${e.toLowerCase()}_by_pk`;
+    if (lower.endsWith("update")) return `update_${e.toLowerCase()}`;
+    if (lower.endsWith("deletebyid")) return `delete_${e.toLowerCase()}_by_pk`;
+    if (lower.endsWith("delete")) return `delete_${e.toLowerCase()}`;
+  }
+  return original;
+}
 function toPascalCase(str) {
   const camel = str.replace(/[-_ ]+(\w)/g, (_, c) => c ? c.toUpperCase() : "").replace(/^\w/, (c) => c.toLowerCase());
   return camel.charAt(0).toUpperCase() + camel.slice(1);
@@ -1594,6 +1659,9 @@ var CCRequest = class {
     this.headers.Authorization = `Bearer ${token}`;
     this.buildClient();
   }
+  getToken() {
+    return this.config.Authorization || this.headers.Authorization;
+  }
   removeToken() {
     this.config.Authorization = void 0;
     delete this.headers.Authorization;
@@ -1668,12 +1736,21 @@ var CCRequest = class {
     this.config.endpoint = endpoint;
     this.buildClient();
   }
+  getEndpoint() {
+    return this.config.endpoint;
+  }
   setHeader(key, value) {
     this.headers[key] = value;
   }
+  getHeader(key) {
+    return this.headers[key];
+  }
   setHeaders(headers) {
     Object.assign(this.headers, headers);
   }
+  getHeaders() {
+    return this.headers;
+  }
   removeHeader(key) {
     delete this.headers[key];
   }
@@ -1781,18 +1858,26 @@ function getClient() {
 var useInterceptor = (interceptor) => getClient().use(interceptor);
 var setToken = (token) => getClient().setToken(token);
 var removeToken = () => getClient().removeToken();
+var getToken = () => getClient().getToken();
 var setLoginInfo = (loginInfo, remember = false) => getClient().setLoginInfo(loginInfo, remember);
 var removeLoginInfo = () => getClient().removeLoginInfo();
 var getLoginInfo = () => getClient().getLoginInfo();
+var getLoginRoles = () => getClient().getLoginInfo()?.roles;
 var setEndpoint = (endpoint) => getClient().setEndpoint(endpoint);
+var getEndpoint = () => getClient().getEndpoint();
 var setHeader = (key, value) => getClient().setHeader(key, value);
 var setHeaders = (headers) => getClient().setHeaders(headers);
+var getHeaders = () => getClient().getHeaders();
+var getHeader = (key) => getClient().getHeader(key);
 var removeHeader = (key) => getClient().removeHeader(key);
 var clearHeaders = () => getClient().clearHeaders();
 
 // src/core/api/query.ts
 var query = {
-  async list(input, useCache = true, ttl) {
+  // NOTE:
+  // GraphQL batch queries should be implemented via alias + fragment builders.
+  // Deferred until v2 API redesign.
+  async list(input, useCache = false, ttl) {
     return rateLimit("list", "query", async () => {
       input.operationName = input.operationName + "s";
       const { query: q, variables } = buildGraphQLQueryList(input);
@@ -1806,7 +1891,7 @@ var query = {
       return result;
     });
   },
-  async byId(input, useCache = true, ttl) {
+  async byId(input, useCache = false, ttl) {
     return rateLimit("byId", "query", async () => {
       const { query: q, variables } = buildGraphQLQueryByIdFixed(input);
       const key = getCacheKey(q, variables);
@@ -1819,7 +1904,7 @@ var query = {
       return result;
     });
   },
-  async page(input, useCache = true, ttl) {
+  async page(input, useCache = false, ttl) {
     return rateLimit("page", "query", async () => {
       const { query: q, variables } = buildGraphQLQueryPageList(input);
       const key = getCacheKey(q, variables);
@@ -1832,7 +1917,7 @@ var query = {
       return result;
     });
   },
-  async aggregate(input, useCache = true, ttl) {
+  async aggregate(input, useCache = false, ttl) {
     return rateLimit("aggregate", "query", async () => {
       const { query: q, variables } = buildGraphQLQueryAggregate(input);
       const key = getCacheKey(q, variables);
@@ -2085,26 +2170,416 @@ var oss = {
     });
   }
 };
+
+// src/common/date.ts
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const pad = (n) => n.toString().padStart(2, "0");
+  return format.replace("YYYY", d.getFullYear().toString()).replace("MM", pad(d.getMonth() + 1)).replace("DD", pad(d.getDate())).replace("HH", pad(d.getHours())).replace("mm", pad(d.getMinutes())).replace("ss", pad(d.getSeconds()));
+}
+function getStartOfDay(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function getEndOfDay(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function getStartOfWeek(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - d.getDay() + 1);
+  return d;
+}
+function getEndOfWeek(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  d.setDate(d.getDate() - d.getDay() + 7);
+  return d;
+}
+function getStartOfMonth(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setDate(1);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function getEndOfMonth(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  d.setMonth(d.getMonth() + 1, 0);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function diffDays(date1, date2) {
+  return Math.floor(Math.abs((date2.getTime() - date1.getTime()) / (1e3 * 3600 * 24)));
+}
+function addDays(date, n) {
+  const d = new Date(date);
+  d.setDate(d.getDate() + n);
+  return d;
+}
+function secondsToTime(sec) {
+  const h = Math.floor(sec / 3600).toString().padStart(2, "0");
+  const m = Math.floor(sec % 3600 / 60).toString().padStart(2, "0");
+  const s = (sec % 60).toString().padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function fromNow(date) {
+  const d = new Date(date);
+  const now = /* @__PURE__ */ new Date();
+  const diff = (now.getTime() - d.getTime()) / 1e3;
+  if (diff < 60) return `${Math.floor(diff)}\u79D2\u524D`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}\u5206\u949F\u524D`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}\u5C0F\u65F6\u524D`;
+  if (diff < 2592e3) return `${Math.floor(diff / 86400)}\u5929\u524D`;
+  return formatDate(d, "YYYY-MM-DD");
+}
+
+// src/common/object.ts
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function merge(obj1, obj2) {
+  return Object.assign({}, obj1, obj2);
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+function pick(obj, keys) {
+  const result = {};
+  keys.forEach((k) => k in obj && (result[k] = obj[k]));
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  keys.forEach((k) => delete result[k]);
+  return result;
+}
+function get(obj, path3, def) {
+  return String(path3).split(".").reduce((o, k) => o ? o[k] : def, obj) ?? def;
+}
+function set(obj, path3, value) {
+  const keys = String(path3).split(".");
+  let o = obj;
+  keys.slice(0, -1).forEach((k) => {
+    if (!(k in o)) o[k] = {};
+    o = o[k];
+  });
+  o[keys[keys.length - 1]] = value;
+  return obj;
+}
+function isEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function flatten(obj, prefix = "", res = {}) {
+  for (const key in obj) {
+    if (typeof obj[key] === "object" && obj[key] !== null) {
+      flatten(obj[key], prefix + key + ".", res);
+    } else {
+      res[prefix + key] = obj[key];
+    }
+  }
+  return res;
+}
+function unflatten(obj) {
+  const res = {};
+  for (const k in obj) {
+    set(res, k, obj[k]);
+  }
+  return res;
+}
+
+// src/common/arr.ts
+function unique(arr) {
+  return Array.from(new Set(arr));
+}
+function intersection(arr1, arr2) {
+  return arr1.filter((item) => arr2.includes(item));
+}
+function union(arr1, arr2) {
+  return Array.from(/* @__PURE__ */ new Set([...arr1, ...arr2]));
+}
+function groupBy(arr, key) {
+  return arr.reduce((acc, cur) => {
+    const groupKey = String(cur[key]);
+    (acc[groupKey] = acc[groupKey] || []).push(cur);
+    return acc;
+  }, {});
+}
+function difference(arr1, arr2) {
+  return arr1.filter((item) => !arr2.includes(item));
+}
+
+// src/common/number.ts
+function formatMoney(num) {
+  return Number(num).toLocaleString("en-US", { maximumFractionDigits: 2 });
+}
+function add(a, b) {
+  return Math.round((a + b) * 1e10) / 1e10;
+}
+function subtract(a, b) {
+  return Math.round((a - b) * 1e10) / 1e10;
+}
+function multiply(a, b) {
+  return Math.round(a * b * 1e10) / 1e10;
+}
+function divide(a, b) {
+  if (b === 0) return NaN;
+  return Math.round(a / b * 1e10) / 1e10;
+}
+function roundWithPrecision(num, precision = 2) {
+  return Math.round(num * Math.pow(10, precision)) / Math.pow(10, precision);
+}
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function toFixed(num, precision = 2) {
+  return num.toFixed(precision);
+}
+function toPercent(num, total, precision = 2) {
+  if (total === 0) return "0%";
+  return (num / total * 100).toFixed(precision) + "%";
+}
+function toNonExponential(num) {
+  let m = num.toExponential().match(/^\d(?:\.\d+)?/);
+  return m ? Number(m[0]).toString() : num.toString();
+}
+function inRange(num, min, max) {
+  return num >= min && num <= max;
+}
+function toNumber(val) {
+  let n = Number(val);
+  return isNaN(n) ? 0 : n;
+}
+function ceil(num) {
+  return Math.ceil(num);
+}
+function floor(num) {
+  return Math.floor(num);
+}
+function round(num) {
+  return Math.round(num);
+}
+
+// src/common/string.ts
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function truncate(str, length, suffix = "...") {
+  if (str.length <= length) return str;
+  return str.slice(0, length) + suffix;
+}
+function removeAllSpace(str) {
+  return str.replace(/\s+/g, "");
+}
+function trim(str) {
+  return str.trim();
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, v) => v.toUpperCase());
+}
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, v) => v.toUpperCase());
+}
+function uncapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function reverse(str) {
+  return str.split("").reverse().join("");
+}
+function isNumeric(str) {
+  return /^-?\d+(\.\d+)?$/.test(str);
+}
+function isEmail(str) {
+  return /^[\w-\.]+@[\w-]+(\.[\w-]+)+$/.test(str);
+}
+function countSubstr(str, sub) {
+  return str.split(sub).length - 1;
+}
+function randomString(len = 8) {
+  const chars = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return str;
+}
+
+// src/common/crypto.ts
+function base64Encode(input) {
+  if (typeof window !== "undefined" && window.btoa) {
+    return window.btoa(unescape(encodeURIComponent(input)));
+  }
+  return Buffer.from(input, "utf-8").toString("base64");
+}
+function base64Decode(input) {
+  if (typeof window !== "undefined" && window.atob) {
+    return decodeURIComponent(escape(window.atob(input)));
+  }
+  return Buffer.from(input, "base64").toString("utf-8");
+}
+function hashCode(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return hash;
+}
+function md5(str) {
+  let hc = "0123456789abcdef";
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash &= hash;
+  }
+  let v = hash >>> 0;
+  let out = "";
+  for (let i = 0; i < 8; i++) {
+    out = hc.charAt(v & 15) + out;
+    v >>>= 4;
+  }
+  return out.padStart(8, "0");
+}
+function simpleSHA1(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16);
+}
+
+// src/common/file.ts
+function getExtName(filename) {
+  const idx = filename.lastIndexOf(".");
+  return idx > -1 ? filename.slice(idx + 1) : "";
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + "B";
+  let k = 1024;
+  let sizes = ["B", "KB", "MB", "GB", "TB"];
+  let i = Math.floor(Math.log(bytes) / Math.log(k));
+  return (bytes / Math.pow(k, i)).toFixed(2) + sizes[i];
+}
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+    reader.readAsDataURL(file);
+  });
+}
+function base64ToFile(dataurl, filename, mimeType) {
+  const arr = dataurl.split(",");
+  const match = arr[0].match(/:(.*?);/);
+  const mime = mimeType || (match ? match[1] : "");
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new File([u8arr], filename, { type: mime });
+}
 export {
+  add,
+  addDays,
   auth,
+  base64Decode,
+  base64Encode,
+  base64ToFile,
+  capitalize,
+  ceil,
   clearHeaders,
+  countSubstr,
+  deepClone,
+  diffDays,
+  difference,
+  divide,
+  fileToBase64,
+  flatten,
+  floor,
+  formatDate,
+  formatMoney,
+  formatSize,
+  fromNow,
+  get,
   getBrowserDeviceInfo,
   getClient,
   getDeviceInfo,
+  getEndOfDay,
+  getEndOfMonth,
+  getEndOfWeek,
+  getEndpoint,
+  getExtName,
+  getHeader,
+  getHeaders,
+  getLoginInfo,
+  getLoginRoles,
   getRateLimitConfig,
+  getStartOfDay,
+  getStartOfMonth,
+  getStartOfWeek,
+  getToken,
   gql,
+  builders_exports as gqlBuilder,
+  groupBy,
+  hashCode,
+  inRange,
   initGraphQLClient,
+  intersection,
+  isEmail,
+  isEmptyObject,
+  isEqual,
+  isLeapYear,
+  isNumeric,
+  kebabToCamel,
+  md5,
+  merge,
+  multiply,
   mutation,
+  omit,
   oss,
+  pick,
   query,
+  randomInt,
+  randomString,
+  removeAllSpace,
   removeHeader,
   removeToken,
+  reverse,
+  round,
+  roundWithPrecision,
+  secondsToTime,
+  set,
   setEndpoint,
   setHeader,
   setHeaders,
   setRateLimitConfig,
   setToken,
+  simpleSHA1,
   sms,
+  subtract,
+  toCamelCase,
+  toFixed,
+  toNonExponential,
+  toNumber,
+  toPercent,
+  toSnakeCase,
+  trim,
+  truncate,
+  uncapitalize,
+  unflatten,
+  union,
+  unique,
   useInterceptor
 };
 //# sourceMappingURL=index.js.map