nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-WI4XWASA.js

@@ -0,0 +1,208 @@
+import {
+  API_ENDPOINTS,
+  NOLO_CLUSTER_SERVERS,
+  isLocalDevServerOrigin,
+  isNoloClusterServerOrigin,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/app/utils/env.ts
+var processEnv = typeof process !== "undefined" ? process.env : void 0;
+var reactNativeDev = typeof globalThis !== "undefined" && "__DEV__" in globalThis ? globalThis.__DEV__ : void 0;
+var isProduction = processEnv?.NOLO_FORCE_PRODUCTION === "1" || processEnv?.NODE_ENV === "production" || reactNativeDev === false;
+var getIsDesktopApp = () => (typeof process !== "undefined" ? process.env?.NOLO_DESKTOP : processEnv?.NOLO_DESKTOP) === "1" || typeof window !== "undefined" && window.__NOLO_DESKTOP__ === true;
+var isDesktopApp = getIsDesktopApp();
+
+// packages/core/abortError.ts
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.name === "AbortError";
+}
+
+// packages/database/actions/common.ts
+import pino from "pino";
+
+// packages/app/utils/retryFetch.ts
+var TRANSIENT_READ_RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+var DEFAULT_RETRY_DELAYS_MS = [300, 1e3];
+var sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var getRequestMethod = (input, init) => {
+  if (init?.method) return init.method.toUpperCase();
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+};
+var isRetryableReadMethod = (method) => method === "GET" || method === "HEAD";
+var fetchWithTransientReadRetry = async (input, init, options = {}) => {
+  const method = getRequestMethod(input, init);
+  const canRetry = isRetryableReadMethod(method);
+  const delaysMs = options.delaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const retryStatuses = options.retryStatuses ?? TRANSIENT_READ_RETRY_STATUSES;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const wait = options.sleep ?? sleep;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const response = await fetchImpl(input, init);
+      const shouldRetry = canRetry && retryStatuses.has(response.status) && attempt < delaysMs.length;
+      if (!shouldRetry) return response;
+    } catch (error) {
+      const shouldRetry = canRetry && !isAbortError(error) && attempt < delaysMs.length;
+      if (!shouldRetry) throw error;
+    }
+    await wait(delaysMs[attempt]);
+  }
+};
+
+// packages/database/levelNotFoundError.ts
+function isLevelNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.notFound === true || e.name === "NotFoundError" || e.code === "LEVEL_NOT_FOUND" || e.code === "LEVEL_NOT_FOUND_ERROR" || e.message === "NotFound";
+}
+
+// packages/database/actions/common.ts
+var isRN = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var logger = isRN ? {
+  info: (...args) => console.log(...args),
+  warn: (...args) => console.warn(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => console.log(...args),
+  // console.debug in RN behaves like log
+  trace: (...args) => console.log(...args),
+  fatal: (...args) => console.error(...args),
+  child: () => logger
+  // 简单返回自己
+} : pino({
+  level: "info"
+  // transport: {
+  //   target: "pino-pretty",
+  // },
+});
+var normalizeServer = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var mergeConfiguredServers = (currentServer, syncServers) => {
+  const runtimeOrigin = !getIsDesktopApp() && typeof window !== "undefined" && typeof window.location?.origin === "string" && /^https?:\/\//.test(window.location.origin) ? window.location.origin : void 0;
+  const raw = [
+    currentServer,
+    ...Array.isArray(syncServers) ? syncServers : [],
+    runtimeOrigin
+  ].filter(
+    (s) => typeof s === "string" && s.trim().length > 0
+  );
+  const normalized = raw.map(normalizeServer);
+  const shouldIncludeClusterPeers = normalized.some(isNoloClusterServerOrigin) || typeof currentServer === "string" && isLocalDevServerOrigin(currentServer);
+  if (shouldIncludeClusterPeers) {
+    normalized.push(...NOLO_CLUSTER_SERVERS);
+  }
+  return Array.from(new Set(normalized));
+};
+var getAllServers = (currentServer, syncServers, preferredServer) => {
+  const preferredNormalized = typeof preferredServer === "string" && preferredServer.trim().length > 0 ? normalizeServer(preferredServer) : null;
+  const servers = mergeConfiguredServers(
+    currentServer,
+    preferredNormalized && isNoloClusterServerOrigin(preferredNormalized) ? [...Array.isArray(syncServers) ? syncServers : [], preferredNormalized] : syncServers
+  );
+  if (!preferredServer || typeof preferredServer !== "string") {
+    return servers;
+  }
+  const remaining = servers.filter(
+    (server) => normalizeServer(server) !== preferredNormalized
+  );
+  return preferredNormalized ? [preferredNormalized, ...remaining] : remaining;
+};
+var fetchFromClientDb = async (clientDb, dbKey) => {
+  if (!clientDb) {
+    logger.error(
+      { dbKey },
+      "Client database is undefined in fetchFromClientDb"
+    );
+    return null;
+  }
+  try {
+    return await clientDb.get(dbKey);
+  } catch (err) {
+    if (isLevelNotFoundError(err)) {
+      return null;
+    }
+    logger.error({ err, dbKey }, "Failed to get local data");
+    return null;
+  }
+};
+var SERVER_TIMEOUT = 5e3;
+var READ_TIMEOUT_ERROR_NAME = "ReadTimeoutError";
+var isPublicFileDbKey = (dbKey) => dbKey.startsWith("file-");
+var buildReadUrl = (dbKey) => isPublicFileDbKey(dbKey) ? `${API_ENDPOINTS.DATABASE}/file/metadata/${encodeURIComponent(dbKey)}` : `${API_ENDPOINTS.DATABASE}/read/${encodeURIComponent(dbKey)}`;
+var createReadTimeoutError = (server, dbKey) => {
+  const error = new Error(
+    `Timed out reading key "${dbKey}" from ${normalizeServer(server)}.`
+  );
+  error.name = READ_TIMEOUT_ERROR_NAME;
+  return error;
+};
+var isReadTimeoutError = (error) => error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
+var fetchFromServer = async (server, dbKey, token, signal) => {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, SERVER_TIMEOUT);
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    const res = await fetchWithTransientReadRetry(
+      `${server}${buildReadUrl(dbKey)}`,
+      {
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          ...token && { Authorization: `Bearer ${token}` }
+        }
+      }
+    );
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (res.status === 200) {
+      return await res.json();
+    }
+    return null;
+  } catch (err) {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (didTimeout) {
+      throw createReadTimeoutError(server, dbKey);
+    }
+    if (signal?.aborted || isAbortError(err)) {
+      throw err;
+    }
+    return null;
+  }
+};
+var normalizeTimeFields = (data) => ({
+  ...data,
+  createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  updated_at: void 0,
+  created_at: void 0
+});
+
+export {
+  isProduction,
+  getIsDesktopApp,
+  isAbortError,
+  fetchWithTransientReadRetry,
+  logger,
+  getAllServers,
+  fetchFromClientDb,
+  isReadTimeoutError,
+  fetchFromServer,
+  normalizeTimeFields
+};

package/chunk-WWC7I6TA.js

@@ -0,0 +1,8 @@
+// packages/core/optionalNumber.ts
+function asOptionalFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+export {
+  asOptionalFiniteNumber
+};