devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/{index-07q6yxyc.js → index-q8f4kawk.js}

@@ -13,15 +13,44 @@ function defineConfig(config) {
 // src/config/ref.ts
 var resolvedCache = new WeakMap;
 var pendingResolutions = new WeakMap;
+var PENDING_REF_VALUE = "<pending>";
+function extractConfigPathFromImportFn(fn) {
+  let source;
+  try {
+    source = Function.prototype.toString.call(fn);
+  } catch {
+    return PENDING_REF_VALUE;
+  }
+  if (!/import\s*\(/.test(source)) {
+    return PENDING_REF_VALUE;
+  }
+  const match = source.match(/import\s*\(\s*(['"`])([^'"`]+)\1\s*\)/);
+  const raw = match?.[2];
+  if (!raw || raw.length === 0) {
+    throw new Error("ref() could not extract a config path from the import function source. " + "The specifier must be a static string literal — dynamic or computed " + "specifiers (e.g. template literals with expressions) are not supported. " + "If this input has been minified, pass an unminified config source.");
+  }
+  if (match?.[1] === "`" && /\$\{/.test(raw)) {
+    throw new Error("ref() import specifier is a template literal with an embedded expression. " + "The specifier must be a static string literal so the config path can " + "be resolved ahead of time.");
+  }
+  if (raw.length < 2 && !/[./]/.test(raw)) {
+    throw new Error(`ref() extracted a suspiciously short config path (${JSON.stringify(raw)}). ` + "This usually indicates a minified bundle where the original specifier " + "was rewritten. Pass an unminified config source.");
+  }
+  return raw;
+}
 function ref(nameOrImport, maybeImport) {
   const nameOverride = typeof nameOrImport === "string" ? nameOrImport : undefined;
-  const importFn = typeof nameOrImport === "function" ? nameOrImport : maybeImport;
+  let importFn;
+  if (typeof nameOrImport === "function") {
+    importFn = nameOrImport;
+  } else if (typeof maybeImport === "function") {
+    importFn = maybeImport;
+  }
   if (!importFn) {
     throw new Error("ref() requires an import function");
   }
-  const fnSource = importFn.toString();
-  const importMatch = fnSource.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
-  const configPath = importMatch?.[1] ?? "<pending>";
+  const resolvedImportFn = importFn;
+  const configPath = extractConfigPathFromImportFn(resolvedImportFn);
+  const doBindingCache = new Map;
   async function doResolve() {
     const cached = resolvedCache.get(proxy);
     if (cached)
@@ -30,7 +59,7 @@ function ref(nameOrImport, maybeImport) {
     if (pending)
       return pending;
     const promise = (async () => {
-      const module = await importFn();
+      const module = await resolvedImportFn();
       const config = "default" in module ? module.default : module;
       if (!config.name && !nameOverride) {
         throw new Error('Referenced config must have a "name" property');
@@ -43,8 +72,11 @@ function ref(nameOrImport, maybeImport) {
       resolvedCache.set(proxy, resolved);
       return resolved;
     })();
-    pendingResolutions.set(proxy, promise);
-    return promise;
+    const trackedPromise = promise.finally(() => {
+      pendingResolutions.delete(proxy);
+    });
+    pendingResolutions.set(proxy, trackedPromise);
+    return trackedPromise;
   }
   function getResolved() {
     const cached = resolvedCache.get(proxy);
@@ -60,7 +92,7 @@ function ref(nameOrImport, maybeImport) {
           return cached.name;
         if (nameOverride)
           return nameOverride;
-        return "<pending>";
+        return PENDING_REF_VALUE;
       },
       entrypoint,
       __ref: proxy
@@ -74,7 +106,7 @@ function ref(nameOrImport, maybeImport) {
           return cached.name;
         if (nameOverride)
           return nameOverride;
-        return "<pending>";
+        return PENDING_REF_VALUE;
       }
       if (prop === "entrypoint")
         return;
@@ -84,7 +116,11 @@ function ref(nameOrImport, maybeImport) {
     }
   });
   function createDOBinding(bindingName) {
-    return {
+    const cachedBinding = doBindingCache.get(bindingName);
+    if (cachedBinding) {
+      return cachedBinding;
+    }
+    const doBinding = {
       get className() {
         const cached = resolvedCache.get(proxy);
         if (cached?.config.bindings?.durableObjects) {
@@ -96,7 +132,7 @@ function ref(nameOrImport, maybeImport) {
             return doConfig.className;
           }
         }
-        return bindingName;
+        return PENDING_REF_VALUE;
       },
       get scriptName() {
         const cached = resolvedCache.get(proxy);
@@ -104,10 +140,13 @@ function ref(nameOrImport, maybeImport) {
           return cached.name;
         if (nameOverride)
           return nameOverride;
-        return "<pending>";
+        return PENDING_REF_VALUE;
       },
+      kind: "cross-worker",
       __ref: proxy
     };
+    doBindingCache.set(bindingName, doBinding);
+    return doBinding;
   }
   const knownProps = new Set(["name", "config", "configPath", "worker", "__import", "__nameOverride", "resolve", "then"]);
   const proxyTarget = {
@@ -119,7 +158,7 @@ function ref(nameOrImport, maybeImport) {
     },
     configPath,
     worker: workerAccessor,
-    __import: importFn,
+    __import: resolvedImportFn,
     __nameOverride: nameOverride,
     resolve: doResolve
   };
@@ -132,6 +171,13 @@ function ref(nameOrImport, maybeImport) {
         return Reflect.get(target, prop);
       }
       if (typeof prop === "string" && /^[A-Z][A-Z0-9_]*$/.test(prop)) {
+        const cached = resolvedCache.get(proxy);
+        if (cached) {
+          const doBindings = cached.config.bindings?.durableObjects;
+          if (!doBindings || !(prop in doBindings)) {
+            return;
+          }
+        }
         return createDOBinding(prop);
       }
       return Reflect.get(target, prop);
@@ -140,29 +186,19 @@ function ref(nameOrImport, maybeImport) {
       if (typeof prop === "string") {
         if (knownProps.has(prop))
           return true;
-        if (/^[A-Z][A-Z0-9_]*$/.test(prop))
+        if (/^[A-Z][A-Z0-9_]*$/.test(prop)) {
+          const cached = resolvedCache.get(proxy);
+          if (cached) {
+            const doBindings = cached.config.bindings?.durableObjects;
+            return !!doBindings && prop in doBindings;
+          }
           return true;
+        }
       }
       return Reflect.has(target, prop);
     }
   });
   return proxy;
 }
-async function resolveRef(configImport, options) {
-  const result = options?.workerName ? ref(options.workerName, configImport) : ref(configImport);
-  await result.resolve();
-  return result;
-}
-function serviceBinding(refOrLegacy, options) {
-  if ("worker" in refOrLegacy) {
-    const entrypoint2 = options?.entrypoint;
-    return entrypoint2 ? refOrLegacy.worker(entrypoint2) : refOrLegacy.worker;
-  }
-  const entrypoint = options?.entrypoint ?? refOrLegacy.entrypoint;
-  return {
-    service: refOrLegacy.name,
-    ...entrypoint && { entrypoint },
-    __ref: refOrLegacy
-  };
-}
-export { defineConfig, ref, resolveRef, serviceBinding };
+
+export { defineConfig, ref };

package/dist/index-qmmqww7h.js

@@ -0,0 +1,133 @@
+import {
+  createAccountOwnedAPIToken,
+  deleteAccountOwnedAPIToken,
+  listAccountOwnedAPITokens,
+  listAccountTokenPermissionGroups,
+  normalizeDevflareTokenName
+} from "./index-11p28kxx.js";
+import {
+  DEVFLARE_PREVIEW_REGISTRY_DATABASE,
+  cleanupPreviewRegistry,
+  ensurePreviewRegistry,
+  getPreviewRegistryContext,
+  listTrackedDeploymentRecords,
+  listTrackedPreviewRecords,
+  listTrackedPreviewScopeRecords,
+  listTrackedRegistryState,
+  reconcilePreviewRegistry,
+  retirePreviewRegistry
+} from "./index-3jme4hgw.js";
+import {
+  canProceedWithTest,
+  getAllUsageSummaries,
+  getLimits,
+  getUsage,
+  getUsageSummary,
+  isWithinLimits,
+  recordTestUsage,
+  recordUsage,
+  resetUsage,
+  setLimits,
+  setLimitsEnabled,
+  shouldSkip
+} from "./index-15fpa5tx.js";
+import {
+  clearGlobalDefaultAccountId,
+  createD1Database,
+  deleteWorker,
+  getAccountById,
+  getAccountSummary,
+  getAccounts,
+  getAllServiceStatus,
+  getEffectiveAccountId,
+  getGlobalDefaultAccountId,
+  getPrimaryAccount,
+  getServiceStatus,
+  getWorkerVersionDetail,
+  getWorkersSubdomain,
+  getWorkspaceAccountId,
+  hasService,
+  listAIModels,
+  listD1Databases,
+  listKVNamespaces,
+  listR2Buckets,
+  listVectorizeIndexes,
+  listWorkerDeployments,
+  listWorkerVersions,
+  listWorkers,
+  queryD1Database,
+  rawD1DatabaseQuery,
+  renameWorker,
+  setGlobalDefaultAccountId,
+  setWorkspaceAccountId
+} from "./index-1d4jg11n.js";
+import {
+  getApiToken,
+  getWranglerAuth,
+  hasWranglerConfig,
+  isAuthenticated
+} from "./index-mg8vwqxf.js";
+
+// src/cloudflare/index.ts
+var account = {
+  isAuthenticated,
+  hasWranglerConfig,
+  getApiToken,
+  getWranglerAuth,
+  getAccounts,
+  getPrimaryAccount,
+  getAccountById,
+  getAccountSummary,
+  workers: listWorkers,
+  renameWorker,
+  deleteWorker,
+  workerVersions: listWorkerVersions,
+  workerVersion: getWorkerVersionDetail,
+  workerDeployments: listWorkerDeployments,
+  workersSubdomain: getWorkersSubdomain,
+  kv: listKVNamespaces,
+  d1: listD1Databases,
+  createD1Database,
+  queryD1Database,
+  rawD1DatabaseQuery,
+  r2: listR2Buckets,
+  vectorize: listVectorizeIndexes,
+  ai: listAIModels,
+  getServiceStatus,
+  getAllServiceStatus,
+  hasService,
+  getUsage,
+  recordUsage,
+  resetUsage,
+  getAllUsageSummaries,
+  getUsageSummary,
+  getLimits,
+  setLimits,
+  setLimitsEnabled,
+  isWithinLimits,
+  canProceedWithTest,
+  recordTestUsage,
+  shouldSkip,
+  getGlobalDefaultAccountId,
+  setGlobalDefaultAccountId,
+  getWorkspaceAccountId,
+  setWorkspaceAccountId,
+  getEffectiveAccountId,
+  clearGlobalDefaultAccountId,
+  listAccountTokenPermissionGroups,
+  listAccountOwnedAPITokens,
+  createAccountOwnedAPIToken,
+  deleteAccountOwnedAPIToken,
+  normalizeDevflareTokenName,
+  previewRegistryDatabase: DEVFLARE_PREVIEW_REGISTRY_DATABASE,
+  ensurePreviewRegistry,
+  getPreviewRegistryContext,
+  listTrackedPreviewRecords,
+  listTrackedRegistryState,
+  listTrackedPreviewScopeRecords,
+  listTrackedDeploymentRecords,
+  reconcilePreviewRegistry,
+  cleanupPreviewRegistry,
+  retirePreviewRegistry
+};
+export { account };

package/dist/{index-rbht7m9r.js → index-qwgr4q7s.js}

@@ -2,6 +2,7 @@
 import { globby, globbySync } from "globby";
 var DEFAULT_DO_PATTERN = "**/do.*.{ts,js}";
 var DEFAULT_ENTRYPOINT_PATTERN = "**/ep.*.{ts,js}";
+var DEFAULT_WORKFLOW_PATTERN = "**/wf.*.{ts,js}";
 async function findFiles(pattern, options) {
   const { cwd, absolute = true, gitignore = true } = options;
   return globby(pattern, {
@@ -33,4 +34,4 @@ function findFilesSync(pattern, options) {
   });
 }
 
-export { DEFAULT_DO_PATTERN, DEFAULT_ENTRYPOINT_PATTERN, findFiles, findFilesSync };
+export { DEFAULT_DO_PATTERN, DEFAULT_ENTRYPOINT_PATTERN, DEFAULT_WORKFLOW_PATTERN, findFiles, findFilesSync };

package/dist/index-qz6nbwpw.js

@@ -0,0 +1,111 @@
+import {
+  bridgeEnv,
+  getContextOrNull
+} from "./index-6sj0v0dk.js";
+
+// src/env.ts
+var testContextEnv = null;
+var testContextDispose = null;
+function __setTestContext(envBindings, dispose) {
+  testContextEnv = envBindings;
+  testContextDispose = dispose;
+}
+function __clearTestContext() {
+  testContextEnv = null;
+  testContextDispose = null;
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "dispose") {
+      return async () => {
+        if (testContextDispose) {
+          await testContextDispose();
+          __clearTestContext();
+        }
+      };
+    }
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    if (prop === "dispose")
+      return true;
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    if (prop === "dispose") {
+      return { configurable: true, enumerable: false, writable: false };
+    }
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  }
+});
+var vars = new Proxy({}, {
+  get(_target, prop) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  },
+  set(_target, prop) {
+    throw new TypeError(`Cannot assign to '${String(prop)}' on 'vars' because it is read-only.`);
+  },
+  deleteProperty(_target, prop) {
+    throw new TypeError(`Cannot delete property '${String(prop)}' from 'vars' because it is read-only.`);
+  }
+});
+
+export { __setTestContext, __clearTestContext, env, vars };

package/dist/index-rzp9ejrh.js

@@ -0,0 +1,185 @@
+import {
+  resolveConfigForEnvironment
+} from "./index-dfcp9hsd.js";
+
+// src/cli/commands/previews-support/family.ts
+function compareConfiguredWorkerFamilies(left, right) {
+  if (left.role === "primary" && right.role !== "primary") {
+    return -1;
+  }
+  if (left.role !== "primary" && right.role === "primary") {
+    return 1;
+  }
+  return left.baseName.localeCompare(right.baseName);
+}
+function comparePreviewScopeRows(left, right) {
+  const leftTime = left.updatedAt?.getTime() ?? 0;
+  const rightTime = right.updatedAt?.getTime() ?? 0;
+  if (rightTime !== leftTime) {
+    return rightTime - leftTime;
+  }
+  return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const families = new Map;
+  families.set(resolvedConfig.name, {
+    baseName: resolvedConfig.name,
+    roleLabel: "primary",
+    role: "primary"
+  });
+  for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+    const existing = families.get(binding.service);
+    if (existing) {
+      continue;
+    }
+    families.set(binding.service, {
+      baseName: binding.service,
+      roleLabel: bindingName,
+      role: "service"
+    });
+  }
+  return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+  if (!workersSubdomain) {
+    return;
+  }
+  return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+  if (!workerName.startsWith(`${baseName}-`)) {
+    return;
+  }
+  const suffix = workerName.slice(baseName.length + 1).trim();
+  return suffix || undefined;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  return families.map((family) => {
+    const worker = workersByName.get(family.baseName);
+    const status = worker ? "active" : "missing";
+    return {
+      workerName: family.baseName,
+      role: family.roleLabel,
+      status,
+      updatedAt: worker?.modifiedOn,
+      url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : undefined
+    };
+  });
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+  const familyNames = new Set;
+  const workerNames = workers.map((worker) => worker.name);
+  for (const family of families) {
+    if (family.role === "primary") {
+      familyNames.add(family.baseName);
+      continue;
+    }
+    if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) {
+      familyNames.add(family.baseName);
+    }
+  }
+  return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+  return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      worker: workersByName.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.worker?.modifiedOn;
+      if (!currentDate) {
+        return latest;
+      }
+      if (!latest || currentDate.getTime() > latest.getTime()) {
+        return currentDate;
+      }
+      return latest;
+    }, undefined);
+    const primaryEntry = resolvedFamilies.find((entry) => entry.family.role === "primary");
+    const entryWorker = primaryEntry?.worker ?? presentFamilies[0]?.worker;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+    const notes = [];
+    if (missingLabels.length > 0) {
+      notes.push(`missing ${missingLabels.join(", ")}`);
+    }
+    const strategy = "dedicated workers";
+    const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+    return {
+      scope,
+      strategy,
+      workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+      status,
+      updatedAt,
+      notes: notes.length > 0 ? notes.join(" · ") : undefined,
+      entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : undefined
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+  const candidates = new Map;
+  for (const worker of workers) {
+    for (const family of families) {
+      const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+      if (!scope) {
+        continue;
+      }
+      const names = candidates.get(scope) ?? new Set;
+      names.add(worker.name);
+      candidates.set(scope, names);
+    }
+  }
+  return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+    return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+  }));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+  const familyPriority = new Map;
+  for (const family of families) {
+    familyPriority.set(family.baseName, {
+      priority: family.role === "primary" ? 0 : 1,
+      roleLabel: family.roleLabel
+    });
+  }
+  const resolveFamilyForWorker = (workerName) => {
+    for (const family of families) {
+      if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+        const resolved = familyPriority.get(family.baseName);
+        if (resolved) {
+          return {
+            priority: resolved.priority,
+            roleLabel: resolved.roleLabel,
+            baseName: family.baseName
+          };
+        }
+      }
+    }
+    return {
+      priority: 2,
+      roleLabel: workerName
+    };
+  };
+  return [...workerNames].sort((left, right) => {
+    const leftFamily = resolveFamilyForWorker(left);
+    const rightFamily = resolveFamilyForWorker(right);
+    if (leftFamily.priority !== rightFamily.priority) {
+      return leftFamily.priority - rightFamily.priority;
+    }
+    if (leftFamily.roleLabel !== rightFamily.roleLabel) {
+      return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+    }
+    if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) {
+      return leftFamily.baseName.localeCompare(rightFamily.baseName);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+export { collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };