@shopify/create-app 3.84.2 → 3.85.0

package/dist/{chunk-X3DDDXQD.js → chunk-OE3KB4ED.js}

@@ -3,11 +3,12 @@ import {
   fetch,
   getEnvironmentData,
   getLastSeenUserIdAfterAuth,
-  getSensitiveEnvironmentData
-} from "./chunk-5OIQQPNB.js";
+  getSensitiveEnvironmentData,
+  requestIdsCollection
+} from "./chunk-JZCHSJAA.js";
 import {
   runWithRateLimit
-} from "./chunk-REUQOPSX.js";
+} from "./chunk-PGTPDPDU.js";
 import {
   alwaysLogAnalytics,
   alwaysLogMetrics,
@@ -17,14 +18,13 @@ import {
   getArrayContainsDuplicates,
   getArrayRejectingUndefined,
   isShopify,
-  isSpinEnvironment,
   isUnitTest,
   opentelemetryDomain,
   outputContent,
   outputDebug,
   outputToken,
   reportingRateLimit
-} from "./chunk-UVDRANBC.js";
+} from "./chunk-POCJD2ES.js";
 import {
   __commonJS,
   __esm,
@@ -15499,6 +15499,165 @@ var buildHeaders = (currentTime) => ({
   "X-Monorail-Edge-Event-Sent-At-Ms": currentTime.toString()
 });
 
+// ../cli-kit/dist/private/node/analytics/storage.js
+init_cjs_shims();
+
+// ../cli-kit/dist/private/node/analytics/error-categorizer.js
+init_cjs_shims();
+var ErrorCategory;
+(function(ErrorCategory2) {
+  ErrorCategory2.Liquid = "LIQUID", ErrorCategory2.ThemeCheck = "THEME_CHECK", ErrorCategory2.Network = "NETWORK", ErrorCategory2.FileSystem = "FILE_SYSTEM", ErrorCategory2.Authentication = "AUTHENTICATION", ErrorCategory2.Validation = "VALIDATION", ErrorCategory2.Permission = "PERMISSION", ErrorCategory2.RateLimit = "RATE_LIMIT", ErrorCategory2.Json = "JSON", ErrorCategory2.Unknown = "UNKNOWN";
+})(ErrorCategory || (ErrorCategory = {}));
+var ERROR_CATEGORY_TERMS = {
+  [ErrorCategory.Liquid]: ["liquid"],
+  [ErrorCategory.Json]: ["json", "parse response"],
+  [ErrorCategory.ThemeCheck]: ["theme check"],
+  [ErrorCategory.Authentication]: ["unauthorized", "forbidden", "auth", "token", "credential"],
+  [ErrorCategory.Network]: [
+    "eai_again",
+    "econn",
+    "enetunreach",
+    "enotfound",
+    "epipe",
+    "etimedout",
+    "fetch",
+    "network",
+    "request",
+    "socket",
+    "the operation was aborted",
+    "timed out",
+    "timeout"
+  ],
+  [ErrorCategory.FileSystem]: ["enoent", "eacces", "file", "directory", "path"],
+  [ErrorCategory.Permission]: ["permission", "denied", "access", "insufficient"],
+  [ErrorCategory.RateLimit]: ["rate limit", "too many requests", "throttle"],
+  [ErrorCategory.Validation]: ["validation", "invalid", "required"]
+};
+function categorizeError(error) {
+  if (!(error instanceof Error))
+    return ErrorCategory.Unknown;
+  let message = error.message.toLowerCase();
+  for (let [category, terms] of Object.entries(ERROR_CATEGORY_TERMS))
+    if (terms.some((term) => message.includes(term)))
+      return category;
+  return ErrorCategory.Unknown;
+}
+function formatErrorMessage(error, category) {
+  let message = error instanceof Error ? error.message : String(error);
+  return (ERROR_FORMATTERS[category] || formatGenericError)(message);
+}
+var ERROR_FORMATTERS = {
+  [ErrorCategory.Network]: formatNetworkError,
+  [ErrorCategory.Authentication]: formatGenericError,
+  [ErrorCategory.FileSystem]: formatGenericError,
+  [ErrorCategory.RateLimit]: formatGenericError,
+  [ErrorCategory.Json]: formatGenericError,
+  [ErrorCategory.Validation]: formatGenericError,
+  [ErrorCategory.Permission]: formatGenericError,
+  [ErrorCategory.Liquid]: formatGenericError,
+  [ErrorCategory.ThemeCheck]: formatGenericError,
+  [ErrorCategory.Unknown]: formatGenericError
+};
+function formatNetworkError(message) {
+  let httpStatusMatch = message.match(/\b([1-5]\d{2})\b/), connectionErrorMatch = message.match(/\b(E[A-Z]+)\b/), graphqlCodeMatch = message.match(/(?:code|error)[:\s]*(\d{3})/i), normalized = message.toLowerCase().substring(0, 50);
+  return httpStatusMatch?.[1] ? normalized = `http-${httpStatusMatch[1]}-${normalized.replace(/\b\d{3}\b/g, "").trim()}` : graphqlCodeMatch?.[1] ? normalized = `http-${graphqlCodeMatch[1]}-${normalized.replace(/(?:code|error)[:\s]*\d{3}/gi, "").trim()}` : connectionErrorMatch?.[1] ? normalized = `http-000-${connectionErrorMatch[1].toLowerCase()}-${normalized.replace(/\b[eE][A-Z]+\b/g, "").trim()}` : normalized = `http-000-${normalized}`, normalized.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+function formatGenericError(message) {
+  return message.toLowerCase().substring(0, 50).replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// ../cli-kit/dist/private/node/analytics/bounded-collections.js
+init_cjs_shims();
+var BArray = class extends Array {
+  push(...items) {
+    let result = super.push(...items);
+    return this.enforceLimit(), result;
+  }
+  clear() {
+    this.length = 0;
+  }
+  toArray() {
+    return [...this];
+  }
+  enforceLimit() {
+    for (; this.length > 1e3; )
+      this.shift();
+  }
+}, BMap = class extends Map {
+  constructor() {
+    super(...arguments), this.insertionOrder = [];
+  }
+  set(key, value) {
+    return this.has(key) || this.insertionOrder.push(key), super.set(key, value), this.enforceLimit(), this;
+  }
+  delete(key) {
+    let index = this.insertionOrder.indexOf(key);
+    return index > -1 && this.insertionOrder.splice(index, 1), super.delete(key);
+  }
+  clear() {
+    this.insertionOrder = [], super.clear();
+  }
+  toObject() {
+    return Object.fromEntries(this);
+  }
+  enforceLimit() {
+    for (; this.size > 1e3 && this.insertionOrder.length > 0; ) {
+      let oldestKey = this.insertionOrder.shift();
+      oldestKey !== void 0 && super.delete(oldestKey);
+    }
+  }
+};
+
+// ../cli-kit/dist/private/node/analytics/storage.js
+var _runtimeAnalyticsStore = {
+  timings: new BArray(),
+  activeTimings: new BMap(),
+  errors: new BArray(),
+  retries: new BArray(),
+  events: new BArray()
+};
+function recordTiming(eventName) {
+  let now = Date.now();
+  if (!_runtimeAnalyticsStore.activeTimings.has(eventName)) {
+    _runtimeAnalyticsStore.activeTimings.set(eventName, now), recordEvent(`timing:start:${eventName}`);
+    return;
+  }
+  let startTime = _runtimeAnalyticsStore.activeTimings.get(eventName);
+  if (startTime === void 0)
+    return;
+  let duration = now - startTime;
+  _runtimeAnalyticsStore.timings.push({
+    event: eventName,
+    duration
+  }), _runtimeAnalyticsStore.activeTimings.delete(eventName), recordEvent(`timing:end:${eventName}`);
+}
+function recordError(error) {
+  let category = categorizeError(error), errorEntry = {
+    category,
+    message: (error instanceof Error ? error.message : String(error)).substring(0, 200),
+    timestamp: Date.now()
+  };
+  if (errorEntry.category === ErrorCategory.Unknown && !errorEntry.message)
+    return;
+  _runtimeAnalyticsStore.errors.push(errorEntry);
+  let normalizedErrorCategory = category.toLowerCase(), normalizedErrorMessage = formatErrorMessage(error, category);
+  recordEvent(`error:${normalizedErrorCategory}:${normalizedErrorMessage}`);
+}
+function recordEvent(eventName) {
+  _runtimeAnalyticsStore.events.push({
+    name: eventName,
+    timestamp: Date.now()
+  });
+}
+function compileData() {
+  return {
+    timings: _runtimeAnalyticsStore.timings.toArray(),
+    errors: _runtimeAnalyticsStore.errors.toArray(),
+    retries: _runtimeAnalyticsStore.retries.toArray(),
+    events: _runtimeAnalyticsStore.events.toArray()
+  };
+}
+
 // ../cli-kit/dist/private/node/otel-metrics.js
 init_cjs_shims();
 
@@ -15764,7 +15923,7 @@ function defaultOtelOptions() {
 }
 function createMetricRecorder(options) {
   let recorder = "console";
-  return options.skipMetricAnalytics || isUnitTest() || isSpinEnvironment() || (recorder = {
+  return options.skipMetricAnalytics || isUnitTest() || (recorder = {
     type: "otel",
     otel: globalOtelService(options)
   }), recorder;
@@ -15794,36 +15953,6 @@ function recordCommandTiming(recorder, labels, timing) {
   timing.active > 0 && (recorder.otel.record(Name.Duration, timing.active, labels), recorder.otel.record(Name.Elapsed, timing.active, { ...labels, stage: "active" })), timing.network > 0 && recorder.otel.record(Name.Elapsed, timing.network, { ...labels, stage: "network" }), timing.prompt > 0 && recorder.otel.record(Name.Elapsed, timing.prompt, { ...labels, stage: "prompt" });
 }
 
-// ../cli-kit/dist/private/node/request-ids.js
-init_cjs_shims();
-var RequestIDCollection = class _RequestIDCollection {
-  constructor() {
-    this.requestIds = [];
-  }
-  static getInstance() {
-    return _RequestIDCollection.instance || (_RequestIDCollection.instance = new _RequestIDCollection()), _RequestIDCollection.instance;
-  }
-  /**
-   * Add a request ID to the collection
-   * We only report the first MAX_REQUEST_IDS request IDs.
-   */
-  addRequestId(requestId) {
-    requestId && this.requestIds.length < 100 && this.requestIds.push(requestId);
-  }
-  /**
-   * Get all collected request IDs
-   */
-  getRequestIds() {
-    return this.requestIds;
-  }
-  /**
-   * Clear all stored request IDs
-   */
-  clear() {
-    this.requestIds = [];
-  }
-}, requestIdsCollection = RequestIDCollection.getInstance();
-
 // ../cli-kit/dist/public/node/analytics.js
 async function reportAnalyticsEvent(options) {
   try {
@@ -15920,11 +16049,26 @@ function sanitizePayload2(payload) {
   let sanitizedPayloadString = JSON.stringify(payload).replace(/shptka_\w*/g, "*****");
   return JSON.parse(sanitizedPayloadString);
 }
+function recordTiming2(eventName) {
+  recordTiming(eventName);
+}
+function recordError2(error) {
+  return recordError(error), error;
+}
+function recordEvent2(eventName) {
+  recordEvent(eventName);
+}
+function compileData2() {
+  return compileData();
+}
 
 export {
   fanoutHooks,
   getListOfTunnelPlugins,
-  requestIdsCollection,
-  reportAnalyticsEvent
+  reportAnalyticsEvent,
+  recordTiming2 as recordTiming,
+  recordError2 as recordError,
+  recordEvent2 as recordEvent,
+  compileData2 as compileData
 };
-//# sourceMappingURL=chunk-X3DDDXQD.js.map
+//# sourceMappingURL=chunk-OE3KB4ED.js.map

package/dist/{chunk-REUQOPSX.js → chunk-PGTPDPDU.js}

@@ -18,10 +18,10 @@ import {
   require_get_stream,
   runWithTimer,
   writeFile
-} from "./chunk-UVDRANBC.js";
+} from "./chunk-POCJD2ES.js";
 import {
   require_semver
-} from "./chunk-H3GWNOGA.js";
+} from "./chunk-G5HUFNZJ.js";
 import {
   dirname,
   joinPath
@@ -9825,15 +9825,24 @@ var _instance;
 function cliKitStore() {
   return _instance || (_instance = new LocalStorage({ projectName: `shopify-cli-kit${isUnitTest() ? "-test" : ""}` })), _instance;
 }
-function getSession(config = cliKitStore()) {
+function getSessions(config = cliKitStore()) {
   return outputDebug(outputContent`Getting session store...`), config.get("sessionStore");
 }
-function setSession(session, config = cliKitStore()) {
+function setSessions(session, config = cliKitStore()) {
   outputDebug(outputContent`Setting session store...`), config.set("sessionStore", session);
 }
-function removeSession(config = cliKitStore()) {
+function removeSessions(config = cliKitStore()) {
   outputDebug(outputContent`Removing session store...`), config.delete("sessionStore");
 }
+function getCurrentSessionId(config = cliKitStore()) {
+  return outputDebug(outputContent`Getting current session ID...`), config.get("currentSessionId");
+}
+function setCurrentSessionId(sessionId, config = cliKitStore()) {
+  outputDebug(outputContent`Setting current session ID...`), config.set("currentSessionId", sessionId);
+}
+function removeCurrentSessionId(config = cliKitStore()) {
+  outputDebug(outputContent`Removing current session ID...`), config.delete("currentSessionId");
+}
 async function cacheRetrieveOrRepopulate(key, fn, timeout, config = cliKitStore()) {
   let cached = cacheRetrieve(key, config);
   if (cached?.value !== void 0 && (timeout === void 0 || Date.now() - cached.timestamp < timeout))
@@ -9842,21 +9851,21 @@ async function cacheRetrieveOrRepopulate(key, fn, timeout, config = cliKitStore(
   return cacheStore(key, value, config), value;
 }
 function cacheStore(key, value, config = cliKitStore()) {
-  let cache = config.get("cache") || {};
+  let cache = config.get("cache") ?? {};
   cache[key] = { value, timestamp: Date.now() }, config.set("cache", cache);
 }
 function cacheRetrieve(key, config = cliKitStore()) {
-  return (config.get("cache") || {})[key];
+  return (config.get("cache") ?? {})[key];
 }
 function timeIntervalToMilliseconds({ days = 0, hours = 0, minutes = 0, seconds = 0 }) {
   return (days * 24 * 60 * 60 + hours * 60 * 60 + minutes * 60 + seconds) * 1e3;
 }
 async function runAtMinimumInterval(key, timeout, task, config = cliKitStore()) {
-  let cache = config.get("cache") || {}, cacheKey = `most-recent-occurrence-${key}`, cached = cache[cacheKey];
+  let cache = config.get("cache") ?? {}, cacheKey = `most-recent-occurrence-${key}`, cached = cache[cacheKey];
   return cached?.value !== void 0 && Date.now() - cached.timestamp < timeIntervalToMilliseconds(timeout) ? !1 : (await task(), cache[cacheKey] = { value: !0, timestamp: Date.now() }, config.set("cache", cache), !0);
 }
 async function runWithRateLimit(options, config = cliKitStore()) {
-  let { key, limit, timeout, task } = options, cache = config.get("cache") || {}, cacheKey = `rate-limited-occurrences-${key}`, cached = cache[cacheKey], now = Date.now();
+  let { key, limit, timeout, task } = options, cache = config.get("cache") ?? {}, cacheKey = `rate-limited-occurrences-${key}`, cached = cache[cacheKey], now = Date.now();
   if (cached?.value) {
     let windowStart = now - timeIntervalToMilliseconds(timeout), occurrences = cached.value.filter((occurrence) => occurrence >= windowStart);
     if (occurrences.length >= limit)
@@ -10491,7 +10500,7 @@ import urlLib from "node:url";
 import crypto2 from "node:crypto";
 import stream, { PassThrough as PassThroughStream } from "node:stream";
 
-// ../../node_modules/.pnpm/normalize-url@8.0.1/node_modules/normalize-url/index.js
+// ../../node_modules/.pnpm/normalize-url@8.1.0/node_modules/normalize-url/index.js
 init_cjs_shims();
 var DATA_URL_DEFAULT_MIME_TYPE = "text/plain", DATA_URL_DEFAULT_CHARSET = "us-ascii", testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name), supportedProtocols = /* @__PURE__ */ new Set([
   "https:",
@@ -10536,6 +10545,8 @@ function normalizeUrl(urlString, options) {
     removeDirectoryIndex: !1,
     removeExplicitPort: !1,
     sortQueryParameters: !0,
+    removePath: !1,
+    transformPath: !1,
     ...options
   }, typeof options.defaultProtocol == "string" && !options.defaultProtocol.endsWith(":") && (options.defaultProtocol = `${options.defaultProtocol}:`), urlString = urlString.trim(), /^data:/i.test(urlString))
     return normalizeDataURL(urlString, options);
@@ -10560,13 +10571,17 @@ function normalizeUrl(urlString, options) {
   }
   if (urlObject.pathname)
     try {
-      urlObject.pathname = decodeURI(urlObject.pathname);
+      urlObject.pathname = decodeURI(urlObject.pathname).replace(/\\/g, "%5C");
     } catch {
     }
   if (options.removeDirectoryIndex === !0 && (options.removeDirectoryIndex = [/^index\.[a-z]+$/]), Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
     let pathComponents = urlObject.pathname.split("/"), lastComponent = pathComponents[pathComponents.length - 1];
     testParameter(lastComponent, options.removeDirectoryIndex) && (pathComponents = pathComponents.slice(0, -1), urlObject.pathname = pathComponents.slice(1).join("/") + "/");
   }
+  if (options.removePath && (urlObject.pathname = "/"), options.transformPath && typeof options.transformPath == "function") {
+    let pathComponents = urlObject.pathname.split("/").filter(Boolean), newComponents = options.transformPath(pathComponents);
+    urlObject.pathname = newComponents?.length > 0 ? `/${newComponents.join("/")}` : "/";
+  }
   if (urlObject.hostname && (urlObject.hostname = urlObject.hostname.replace(/\.$/, ""), options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname) && (urlObject.hostname = urlObject.hostname.replace(/^www\./, ""))), Array.isArray(options.removeQueryParameters))
     for (let key of [...urlObject.searchParams.keys()])
       testParameter(key, options.removeQueryParameters) && urlObject.searchParams.delete(key);
@@ -10574,11 +10589,17 @@ function normalizeUrl(urlString, options) {
     for (let key of [...urlObject.searchParams.keys()])
       testParameter(key, options.keepQueryParameters) || urlObject.searchParams.delete(key);
   if (options.sortQueryParameters) {
+    let originalSearch = urlObject.search;
     urlObject.searchParams.sort();
     try {
       urlObject.search = decodeURIComponent(urlObject.search);
     } catch {
     }
+    let partsWithoutEquals = originalSearch.slice(1).split("&").filter((p) => p && !p.includes("="));
+    for (let part of partsWithoutEquals) {
+      let decoded = decodeURIComponent(part);
+      urlObject.search = urlObject.search.replace(`?${decoded}=`, `?${decoded}`).replace(`&${decoded}=`, `&${decoded}`);
+    }
   }
   options.removeTrailingSlash && (urlObject.pathname = urlObject.pathname.replace(/\/$/, "")), options.removeExplicitPort && urlObject.port && (urlObject.port = "");
   let oldUrlString = urlString;
@@ -13839,9 +13860,12 @@ function inferPackageManager(optionsPackageManager, env = process.env) {
 export {
   require_ajv,
   LocalStorage,
-  getSession,
-  setSession,
-  removeSession,
+  getSessions,
+  setSessions,
+  removeSessions,
+  getCurrentSessionId,
+  setCurrentSessionId,
+  removeCurrentSessionId,
   cacheRetrieveOrRepopulate,
   cacheStore,
   cacheRetrieve,
@@ -13909,4 +13933,4 @@ deep-extend/lib/deep-extend.js:
    * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    *)
 */
-//# sourceMappingURL=chunk-REUQOPSX.js.map
+//# sourceMappingURL=chunk-PGTPDPDU.js.map