@dbx-tools/shared-core 0.6.81 → 0.6.85

package/README.md

@@ -10,7 +10,6 @@ namespaces so call sites stay explicit:
 import {
   async,
   brand,
-  env,
   error,
   hash,
   http,
@@ -156,41 +155,6 @@ field off parsed JSON. `parseList()` normalizes a config value that may arrive a
 an array or as one comma/whitespace-separated env string, de-duplicating as it
 goes.
 
-## Configuration From The Environment
-
-```ts
-const config = {
-  isDatabricksApp: env.isAppEnv(),
-  host: env.string(options.host, "SMTP_HOST"),
-  // Several names for one setting; earlier names win.
-  appId: env.string(options.appId, ["TEAMS_APP_ID", "MICROSOFT_APP_ID"]),
-  timeoutMs: env.positiveInt(options.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000),
-  threshold: env.positiveNumber(options.threshold, "FUZZY_THRESHOLD", 0.4),
-  fuzzy: env.boolean(options.fuzzy, "SEARCH_FUZZY") ?? true,
-  fallbacks: env.list(options.fallbacks, "MODEL_FALLBACKS"),
-};
-```
-
-Every plugin resolves config the same way - the caller's typed value, else one or
-more environment variables, else a default - and hand-writing that chain per
-field is how `config.x ?? Number(process.env.X)` bugs get in. `positiveInt()`
-floors, so a count cannot go fractional; `positiveNumber()` keeps the fraction
-for a threshold or ratio. `boolean()` goes through `object.toBoolean()`, so the
-loose spellings an env var actually carries (`1`, `on`, `yes`) are accepted, and
-returns `undefined` when neither source is interpretable so `??` picks the
-default. A name that is SET but unusable is not skipped for a later name in the
-chain - ignoring what a deployment explicitly configured hides the mistake.
-
-Browser-safe: `process` is reached through `globalThis` and guarded, so every
-lookup simply misses off-process and the caller's fallback applies.
-`isAppEnv()` checks the required Databricks App name, workspace host, and valid
-TCP port shape without adding Node types to this shared package.
-
-Pair it with `object.optional()` when a resolved value is an optional field -
-`...object.optional("endpoint", env.string(...))` keeps an absent field ABSENT
-rather than setting it to an explicit `undefined`, which
-`exactOptionalPropertyTypes` rejects.
-
 ## Objects And Predicates
 
 ```ts
@@ -442,10 +406,6 @@ without paying formatting cost when disabled.
   field spreading, deep equality, JSON-round-trip guards
   (`isSerializableValue`), canonical identity keys (`toStableKey`), shape types,
   and lazy sequence transforms + collection helpers.
-- `env` - config-over-environment resolution, Databricks App runtime detection,
-  and TCP port bounds. `name()` gives the primary variable name for a log line
-  or error - an `EnvKey` may be a bare string, so indexing `keys[0]` yields a
-  character, not a name.
 - `predicate` - composable boolean/type predicates.
 - `pattern` - literal / glob / `/regex/` allow-list matching compiled to a
   predicate.

package/index.ts

@@ -4,7 +4,7 @@
 
 export * as async from "./src/async.ts";
 export * as brand from "./src/brand.ts";
-export * as env from "./src/env.ts";
+export * as context from "./src/context.ts";
 export * as error from "./src/error.ts";
 export * as execution from "./src/execution.ts";
 export * as functionModule from "./src/function.ts";
@@ -21,8 +21,7 @@ export * as token from "./src/token.ts";
 export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
-export { MAX_TCP_PORT } from "./src/env.ts";
-export type { EnvKey } from "./src/env.ts";
+export type { ContextLoader } from "./src/context.ts";
 export type { ErrorContext } from "./src/error.ts";
 export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
 export type { MemoizeOptions } from "./src/function.ts";

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 export * as async from "./src/async.ts";
 export * as brand from "./src/brand.ts";
-export * as env from "./src/env.ts";
+export * as context from "./src/context.ts";
 export * as error from "./src/error.ts";
 export * as execution from "./src/execution.ts";
 export * as functionModule from "./src/function.ts";
@@ -17,8 +17,7 @@ export * as token from "./src/token.ts";
 export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
-export { MAX_TCP_PORT } from "./src/env.ts";
-export type { EnvKey } from "./src/env.ts";
+export type { ContextLoader } from "./src/context.ts";
 export type { ErrorContext } from "./src/error.ts";
 export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
 export type { MemoizeOptions } from "./src/function.ts";

package/lib/index.js

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as async from "./src/async.js";
 export * as brand from "./src/brand.js";
-export * as env from "./src/env.js";
+export * as context from "./src/context.js";
 export * as error from "./src/error.js";
 export * as execution from "./src/execution.js";
 export * as functionModule from "./src/function.js";
@@ -18,6 +18,5 @@ export * as predicate from "./src/predicate.js";
 export * as string from "./src/string.js";
 export * as token from "./src/token.js";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.js";
-export { MAX_TCP_PORT } from "./src/env.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/context.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The ambient CONTEXT a cached value belongs to, and a cache keyed by it.
+ *
+ * Most of the expensive lookups in this repo are pure functions of the directory
+ * (or the page) they were asked from: `npm prefix`, `git rev-parse`, a `.env`
+ * file, `databricks bundle validate`. Memoizing them with
+ * {@link functionModule.memoize} is wrong in exactly one situation, and it is the
+ * situation a CLI hits: the process changes directory, and the cached answer now
+ * describes somewhere else. Every caller therefore grew the same guard - resolve
+ * `cwd`, compare it against `process.cwd()`, and skip the cache when they differ
+ * (see the `cacheEnabled` dance this module replaced in node-core's `project`).
+ *
+ * This is that guard, once. A cache slot stores the context it was loaded under,
+ * so a context change (a moved `cwd`, a different origin) MISSES rather than
+ * returns a stale value, and a lookup for some OTHER directory is not cached at
+ * all - one off-context call must not evict or poison the hot path.
+ *
+ * The context is the process working directory on a server and
+ * `location.origin` in a browser, whichever this runtime has. Browser-safe:
+ * `process` and `location` are reached through `globalThis` and guarded, so this
+ * module needs no Node types and simply has no context off-process.
+ *
+ * @example
+ * const roots = context.cached(["project", "npm", "prefix"], (cwd) =>
+ *   spawnSync("npm", ["prefix"], { cwd }),
+ * );
+ *
+ * @module
+ */
+import type { OneOrMany } from "./object.ts";
+/** A loader for a cached value; receives the resolved context. */
+export type ContextLoader<T> = (context: string | undefined) => T;
+/**
+ * The current context: the process working directory, else `location.origin`,
+ * else `undefined` (a runtime with neither, where nothing is cacheable).
+ */
+export declare function getContext(): string | undefined;
+/**
+ * Whether `value` names a context this runtime is CURRENTLY in - the live `cwd`
+ * or origin. This is the cacheability test: a value loaded for some other
+ * directory is correct but not shareable, so it is never stored.
+ */
+export declare function isContext(value: unknown): boolean;
+/**
+ * Load `name` through `loader`, reusing the cached value while the context is
+ * unchanged.
+ *
+ * `context` selects what the value is loaded FOR: omitted, `null`, or `"."` mean
+ * the current context. It is passed straight to `loader`, so a loader never has
+ * to reach for `process.cwd()` itself.
+ *
+ * Caching happens only when the resolved context is one this runtime is in
+ * ({@link isContext}), so `cached(name, loader, "/somewhere/else")` always calls
+ * `loader` and stores nothing. A stored entry remembers its context and is
+ * discarded on the next call once that context changes. A thrown error is never
+ * cached; a rejected promise evicts its entry so a later call retries.
+ *
+ * `name` identifies the slot and must be stable across calls - pass a
+ * module-qualified list of string parts (`["project", command, ...args]`) so two
+ * modules cannot collide on one slot.
+ */
+export declare function cached<T>(name: OneOrMany<string>, loader: ContextLoader<T>, context?: string | null): T;
+/** Drop one cached slot, or the whole cache when `name` is omitted. */
+export declare function clear(name?: OneOrMany<string>): void;

package/lib/src/context.js

@@ -0,0 +1,148 @@
+/**
+ * The ambient CONTEXT a cached value belongs to, and a cache keyed by it.
+ *
+ * Most of the expensive lookups in this repo are pure functions of the directory
+ * (or the page) they were asked from: `npm prefix`, `git rev-parse`, a `.env`
+ * file, `databricks bundle validate`. Memoizing them with
+ * {@link functionModule.memoize} is wrong in exactly one situation, and it is the
+ * situation a CLI hits: the process changes directory, and the cached answer now
+ * describes somewhere else. Every caller therefore grew the same guard - resolve
+ * `cwd`, compare it against `process.cwd()`, and skip the cache when they differ
+ * (see the `cacheEnabled` dance this module replaced in node-core's `project`).
+ *
+ * This is that guard, once. A cache slot stores the context it was loaded under,
+ * so a context change (a moved `cwd`, a different origin) MISSES rather than
+ * returns a stale value, and a lookup for some OTHER directory is not cached at
+ * all - one off-context call must not evict or poison the hot path.
+ *
+ * The context is the process working directory on a server and
+ * `location.origin` in a browser, whichever this runtime has. Browser-safe:
+ * `process` and `location` are reached through `globalThis` and guarded, so this
+ * module needs no Node types and simply has no context off-process.
+ *
+ * @example
+ * const roots = context.cached(["project", "npm", "prefix"], (cwd) =>
+ *   spawnSync("npm", ["prefix"], { cwd }),
+ * );
+ *
+ * @module
+ */
+const CACHE = new Map();
+/**
+ * The current context: the process working directory, else `location.origin`,
+ * else `undefined` (a runtime with neither, where nothing is cacheable).
+ */
+export function getContext() {
+    for (const context of getContexts())
+        return context;
+    return undefined;
+}
+/**
+ * Whether `value` names a context this runtime is CURRENTLY in - the live `cwd`
+ * or origin. This is the cacheability test: a value loaded for some other
+ * directory is correct but not shareable, so it is never stored.
+ */
+export function isContext(value) {
+    const context = toContext(value);
+    if (context === undefined)
+        return false;
+    for (const candidate of getContexts()) {
+        if (candidate === context)
+            return true;
+    }
+    return false;
+}
+/**
+ * Load `name` through `loader`, reusing the cached value while the context is
+ * unchanged.
+ *
+ * `context` selects what the value is loaded FOR: omitted, `null`, or `"."` mean
+ * the current context. It is passed straight to `loader`, so a loader never has
+ * to reach for `process.cwd()` itself.
+ *
+ * Caching happens only when the resolved context is one this runtime is in
+ * ({@link isContext}), so `cached(name, loader, "/somewhere/else")` always calls
+ * `loader` and stores nothing. A stored entry remembers its context and is
+ * discarded on the next call once that context changes. A thrown error is never
+ * cached; a rejected promise evicts its entry so a later call retries.
+ *
+ * `name` identifies the slot and must be stable across calls - pass a
+ * module-qualified list of string parts (`["project", command, ...args]`) so two
+ * modules cannot collide on one slot.
+ */
+export function cached(name, loader, context) {
+    const resolved = toContext(context) ?? getContext();
+    const key = resolved !== undefined && isContext(resolved) ? cacheKey(name) : undefined;
+    if (key !== undefined) {
+        const entry = CACHE.get(key);
+        if (entry && entry.context === resolved)
+            return entry.value;
+    }
+    const value = loader(resolved);
+    if (key !== undefined && resolved !== undefined) {
+        const entry = { context: resolved, value };
+        CACHE.set(key, entry);
+        if (isThenable(value)) {
+            void Promise.resolve(value).catch(() => {
+                if (CACHE.get(key) === entry)
+                    CACHE.delete(key);
+            });
+        }
+    }
+    return value;
+}
+/** Drop one cached slot, or the whole cache when `name` is omitted. */
+export function clear(name) {
+    if (name === undefined)
+        CACHE.clear();
+    else
+        CACHE.delete(cacheKey(name));
+}
+/**
+ * Canonical slot key. `JSON.stringify` over the parts rather than a hash: the
+ * parts are already strings, and an exact key cannot collide two unrelated
+ * lookups onto one slot the way a truncated digest can.
+ */
+function cacheKey(name) {
+    return JSON.stringify(typeof name === "string" ? [name] : name);
+}
+/**
+ * Every context this runtime reports, in precedence order. A server yields its
+ * `cwd`; a browser yields `location.origin`. A hybrid (a worker with both) yields
+ * both, which is what makes {@link isContext} accept either.
+ */
+function* getContexts() {
+    const global = globalThis;
+    const cwd = global.process?.cwd;
+    if (typeof cwd === "function") {
+        let current;
+        try {
+            current = cwd();
+        }
+        catch {
+            current = undefined;
+        }
+        const context = toContext(current);
+        if (context !== undefined)
+            yield context;
+    }
+    const origin = toContext(global.location?.origin);
+    if (origin !== undefined)
+        yield origin;
+}
+/** A non-blank string, with `"."` treated as "the current context" (unresolved). */
+function toContext(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed && trimmed !== "." ? trimmed : undefined;
+}
+/** Duck-type any value with a callable `.then` as a thenable. */
+function isThenable(value) {
+    return (value instanceof Promise ||
+        (typeof value === "object" &&
+            value !== null &&
+            "then" in value &&
+            typeof value.then === "function"));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The ambient CONTEXT a cached value belongs to, and a cache keyed by it.\n *\n * Most of the expensive lookups in this repo are pure functions of the directory\n * (or the page) they were asked from: `npm prefix`, `git rev-parse`, a `.env`\n * file, `databricks bundle validate`. Memoizing them with\n * {@link functionModule.memoize} is wrong in exactly one situation, and it is the\n * situation a CLI hits: the process changes directory, and the cached answer now\n * describes somewhere else. Every caller therefore grew the same guard - resolve\n * `cwd`, compare it against `process.cwd()`, and skip the cache when they differ\n * (see the `cacheEnabled` dance this module replaced in node-core's `project`).\n *\n * This is that guard, once. A cache slot stores the context it was loaded under,\n * so a context change (a moved `cwd`, a different origin) MISSES rather than\n * returns a stale value, and a lookup for some OTHER directory is not cached at\n * all - one off-context call must not evict or poison the hot path.\n *\n * The context is the process working directory on a server and\n * `location.origin` in a browser, whichever this runtime has. Browser-safe:\n * `process` and `location` are reached through `globalThis` and guarded, so this\n * module needs no Node types and simply has no context off-process.\n *\n * @example\n * const roots = context.cached([\"project\", \"npm\", \"prefix\"], (cwd) =>\n *   spawnSync(\"npm\", [\"prefix\"], { cwd }),\n * );\n *\n * @module\n */\n\nimport type { OneOrMany } from \"./object.ts\";\n\n/** A loader for a cached value; receives the resolved context. */\nexport type ContextLoader<T> = (context: string | undefined) => T;\n\ninterface CacheEntry {\n  context: string;\n  value: unknown;\n}\n\nconst CACHE = new Map<string, CacheEntry>();\n\n/**\n * The current context: the process working directory, else `location.origin`,\n * else `undefined` (a runtime with neither, where nothing is cacheable).\n */\nexport function getContext(): string | undefined {\n  for (const context of getContexts()) return context;\n  return undefined;\n}\n\n/**\n * Whether `value` names a context this runtime is CURRENTLY in - the live `cwd`\n * or origin. This is the cacheability test: a value loaded for some other\n * directory is correct but not shareable, so it is never stored.\n */\nexport function isContext(value: unknown): boolean {\n  const context = toContext(value);\n  if (context === undefined) return false;\n  for (const candidate of getContexts()) {\n    if (candidate === context) return true;\n  }\n  return false;\n}\n\n/**\n * Load `name` through `loader`, reusing the cached value while the context is\n * unchanged.\n *\n * `context` selects what the value is loaded FOR: omitted, `null`, or `\".\"` mean\n * the current context. It is passed straight to `loader`, so a loader never has\n * to reach for `process.cwd()` itself.\n *\n * Caching happens only when the resolved context is one this runtime is in\n * ({@link isContext}), so `cached(name, loader, \"/somewhere/else\")` always calls\n * `loader` and stores nothing. A stored entry remembers its context and is\n * discarded on the next call once that context changes. A thrown error is never\n * cached; a rejected promise evicts its entry so a later call retries.\n *\n * `name` identifies the slot and must be stable across calls - pass a\n * module-qualified list of string parts (`[\"project\", command, ...args]`) so two\n * modules cannot collide on one slot.\n */\nexport function cached<T>(\n  name: OneOrMany<string>,\n  loader: ContextLoader<T>,\n  context?: string | null,\n): T {\n  const resolved = toContext(context) ?? getContext();\n  const key = resolved !== undefined && isContext(resolved) ? cacheKey(name) : undefined;\n  if (key !== undefined) {\n    const entry = CACHE.get(key);\n    if (entry && entry.context === resolved) return entry.value as T;\n  }\n  const value = loader(resolved);\n  if (key !== undefined && resolved !== undefined) {\n    const entry: CacheEntry = { context: resolved, value };\n    CACHE.set(key, entry);\n    if (isThenable(value)) {\n      void Promise.resolve(value).catch(() => {\n        if (CACHE.get(key) === entry) CACHE.delete(key);\n      });\n    }\n  }\n  return value;\n}\n\n/** Drop one cached slot, or the whole cache when `name` is omitted. */\nexport function clear(name?: OneOrMany<string>): void {\n  if (name === undefined) CACHE.clear();\n  else CACHE.delete(cacheKey(name));\n}\n\n/**\n * Canonical slot key. `JSON.stringify` over the parts rather than a hash: the\n * parts are already strings, and an exact key cannot collide two unrelated\n * lookups onto one slot the way a truncated digest can.\n */\nfunction cacheKey(name: OneOrMany<string>): string {\n  return JSON.stringify(typeof name === \"string\" ? [name] : name);\n}\n\n/**\n * Every context this runtime reports, in precedence order. A server yields its\n * `cwd`; a browser yields `location.origin`. A hybrid (a worker with both) yields\n * both, which is what makes {@link isContext} accept either.\n */\nfunction* getContexts(): Generator<string, void, void> {\n  const global = globalThis as {\n    process?: { cwd?: () => string };\n    location?: { origin?: string };\n  };\n  const cwd = global.process?.cwd;\n  if (typeof cwd === \"function\") {\n    let current: unknown;\n    try {\n      current = cwd();\n    } catch {\n      current = undefined;\n    }\n    const context = toContext(current);\n    if (context !== undefined) yield context;\n  }\n  const origin = toContext(global.location?.origin);\n  if (origin !== undefined) yield origin;\n}\n\n/** A non-blank string, with `\".\"` treated as \"the current context\" (unresolved). */\nfunction toContext(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  return trimmed && trimmed !== \".\" ? trimmed : undefined;\n}\n\n/** Duck-type any value with a callable `.then` as a thenable. */\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    value instanceof Promise ||\n    (typeof value === \"object\" &&\n      value !== null &&\n      \"then\" in value &&\n      typeof (value as PromiseLike<unknown>).then === \"function\")\n  );\n}\n"]}

package/lib/src/object.d.ts

@@ -24,7 +24,7 @@
  */
 /** Lazy sequence over iterable source(s). See {@link sequence}. */
 export type Sequence<T> = SequenceImpl<T>;
-type SequenceSource<T> = Iterable<T> | ReadonlyMap<unknown, T> | OneOrMany<T> | null | undefined;
+type SequenceSource<T> = Iterable<T> | ReadonlyMap<unknown, T> | OneOrMany<T> | Extract<T, string> | null | undefined;
 /**
  * A non-scalar {@link Iterable} - one to treat as a collection of elements
  * rather than a scalar. {@link isContainer} narrows to this, excluding strings,
@@ -449,7 +449,7 @@ export declare function toStableKey(value: unknown, seen?: Set<object>): string;
  *
  * @example
  * return {
- *   ...optional("appId", env.text("MICROSOFT_APP_ID")),
+ *   ...optional("appId", configuredAppId),
  *   ...optional("endpoint", config.endpoint),
  * };
  */