@malloydata/malloy 0.0.371 → 0.0.373

package/dist/api/foundation/config_resolve.js

@@ -0,0 +1,230 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+const registry_1 = require("../../connection/registry");
+/**
+ * Walk a compiled tree against the overlay dict and produce a plain
+ * resolved POJO.
+ *
+ * Two distinct "defaults" mechanisms, deliberately separated:
+ *
+ *   1. **Property defaults** (`applyPropertyDefaults`) — fill in missing
+ *      properties on *every* connection entry, user-listed or fabricated.
+ *      This is a uniform per-property rule; there is no asymmetry between
+ *      explicit and auto-generated entries.
+ *
+ *   2. **`includeDefaultConnections`** (`fabricateMissingConnections`) —
+ *      fabricate a bare `{is: typeName}` entry for each registered backend
+ *      not already represented. Property defaults then fill in their
+ *      properties via (1).
+ *
+ *   Order matters: fabrication runs before property defaults so that
+ *   fabricated entries pick up defaults in the same pass as user-listed
+ *   ones.
+ *
+ * Three unresolved-reference cases, each with different handling:
+ *   1. Unknown overlay source    → warning, drop property
+ *   2. Known overlay → undefined → silent drop
+ *   3. Property default → unresolved (either of the above inside a default)
+ *                                → silent drop (a default is a hint, not a requirement)
+ */
+function resolveConfig(compiled, overlays, log) {
+    const resolved = { connections: {} };
+    let includeDefaultConnections = false;
+    for (const [key, node] of Object.entries(compiled.entries)) {
+        switch (key) {
+            case 'connections': {
+                if (node.kind !== 'dict')
+                    break;
+                resolved.connections = resolveConnections(node, overlays, log);
+                break;
+            }
+            case 'manifestPath': {
+                const v = resolveNode(node, overlays, log);
+                if (typeof v === 'string')
+                    resolved.manifestPath = v;
+                break;
+            }
+            case 'virtualMap': {
+                // virtualMap is literal data — the class body converts it to the
+                // runtime Map-of-Maps representation.
+                resolved.virtualMap = resolveNode(node, overlays, log);
+                break;
+            }
+            case 'includeDefaultConnections': {
+                const v = resolveNode(node, overlays, log);
+                if (typeof v === 'boolean')
+                    includeDefaultConnections = v;
+                break;
+            }
+        }
+    }
+    if (includeDefaultConnections) {
+        fabricateMissingConnections(resolved.connections);
+    }
+    // Property defaults apply to every entry — user-listed and fabricated
+    // alike. This is the fix for the earlier bug where defaults only fired
+    // during fabrication, leaving explicit entries silently underconfigured.
+    applyPropertyDefaults(resolved.connections, overlays);
+    return resolved;
+}
+// =============================================================================
+// Generic walk
+// =============================================================================
+/**
+ * Walk a single node and produce its resolved value. References that fail
+ * to resolve return `undefined`; the parent dict walker then drops the
+ * corresponding property.
+ */
+function resolveNode(node, overlays, log) {
+    switch (node.kind) {
+        case 'value':
+            return node.value;
+        case 'reference':
+            return resolveReference(node, overlays, log);
+        case 'dict': {
+            const out = {};
+            for (const [k, child] of Object.entries(node.entries)) {
+                const r = resolveNode(child, overlays, log);
+                if (r !== undefined)
+                    out[k] = r;
+            }
+            return out;
+        }
+    }
+}
+function resolveReference(ref, overlays, log) {
+    const overlay = overlays[ref.source];
+    if (!overlay) {
+        // Case 1: unknown overlay source — warn and drop.
+        log.push({
+            message: `unknown overlay source "${ref.source}" for reference path ${JSON.stringify(ref.path)}`,
+            severity: 'warn',
+            code: 'config-overlay',
+        });
+        return undefined;
+    }
+    // Case 2: overlay returns undefined — silent drop (no log push).
+    return overlay(ref.path);
+}
+// =============================================================================
+// Connections
+// =============================================================================
+function resolveConnections(node, overlays, log) {
+    const result = {};
+    for (const [name, connNode] of Object.entries(node.entries)) {
+        if (connNode.kind !== 'dict')
+            continue;
+        const resolved = resolveNode(connNode, overlays, log);
+        // compileConnectionEntry guarantees `is` is a string value node, and
+        // resolveNode preserves it. Any connection without `is` is a bug in the
+        // compiler; skip it defensively.
+        if (typeof resolved['is'] !== 'string')
+            continue;
+        result[name] = resolved;
+    }
+    return result;
+}
+// =============================================================================
+// Fabrication and property defaults
+// =============================================================================
+/**
+ * Fabricate a bare `{is: typeName}` entry for each registered connection
+ * type not already represented in `connections`. Only runs when the
+ * `includeDefaultConnections` flag is set on the config. Property values
+ * are *not* filled in here — that is the job of `applyPropertyDefaults`,
+ * which runs unconditionally on every entry in a later pass.
+ *
+ * A user-named connection that happens to share the type name but points
+ * at a different backend is left alone.
+ *
+ * Mutates `connections` in place. Called only by `resolveConfig` on its
+ * own freshly-built object.
+ */
+function fabricateMissingConnections(connections) {
+    const presentTypes = new Set();
+    for (const entry of Object.values(connections)) {
+        if (typeof entry.is === 'string')
+            presentTypes.add(entry.is);
+    }
+    for (const typeName of (0, registry_1.getRegisteredConnectionTypes)()) {
+        // `presentTypes` catches {mydb: {is: 'duckdb'}}; the name check catches
+        // {duckdb: {is: 'jsondb'}}. Both cases leave the registered `duckdb`
+        // type alone — the first because it's already represented, the second
+        // because we can't use the obvious name without clobbering.
+        if (presentTypes.has(typeName))
+            continue;
+        if (connections[typeName])
+            continue;
+        connections[typeName] = { is: typeName };
+    }
+}
+/**
+ * For every connection entry, fill in any property that the user didn't
+ * specify and whose `ConnectionPropertyDefinition` declares a `default`.
+ * Runs uniformly on both user-listed and fabricated entries — the earlier
+ * behavior of only firing during fabrication was a bug that left explicit
+ * entries silently underconfigured (e.g. a user-listed `duckdb` never
+ * picked up `workingDirectory: {config: 'rootDirectory'}`).
+ *
+ * Defaults that are reference-shaped resolve through the overlays via
+ * `resolveDefault`. Unresolved defaults are silently dropped (case 3).
+ * User-specified values are never overwritten.
+ *
+ * Interaction with inline references: if the user specified a property
+ * as a reference-shaped value that failed to resolve (e.g. `{env: 'UNSET'}`),
+ * `resolveConnections` already dropped it before we see the entry. From
+ * our perspective the property is simply absent, so the default applies —
+ * effectively turning inline references into "try this first, else fall
+ * back to the default." This is almost always what users want.
+ *
+ * Mutates `connections` in place. Called only by `resolveConfig` on its
+ * own freshly-built object.
+ */
+function applyPropertyDefaults(connections, overlays) {
+    var _a;
+    for (const entry of Object.values(connections)) {
+        const typeName = entry.is;
+        if (typeof typeName !== 'string')
+            continue;
+        const props = (_a = (0, registry_1.getConnectionProperties)(typeName)) !== null && _a !== void 0 ? _a : [];
+        for (const prop of props) {
+            if (prop.default === undefined)
+                continue;
+            if (entry[prop.name] !== undefined)
+                continue;
+            const v = resolveDefault(prop.default, overlays);
+            if (v !== undefined)
+                entry[prop.name] = v;
+        }
+    }
+}
+/**
+ * Resolve a property `default` field. Literals pass through; single-key
+ * reference-shaped objects are resolved through the overlays. Case 3:
+ * an unresolved default is a hint, not a requirement — always silent drop.
+ */
+function resolveDefault(def, overlays) {
+    if (typeof def !== 'object')
+        return def;
+    const keys = Object.keys(def);
+    if (keys.length !== 1)
+        return undefined;
+    const source = keys[0];
+    const raw = def[source];
+    const path = typeof raw === 'string' ? [raw] : raw;
+    // The type says `raw` is `string | string[]`, but `default` comes from
+    // registered backend definitions which are runtime-dynamic — a
+    // malformed registration would blow up inside the overlay otherwise.
+    if (!Array.isArray(path))
+        return undefined;
+    const overlay = overlays[source];
+    if (!overlay)
+        return undefined;
+    return overlay(path);
+}
+//# sourceMappingURL=config_resolve.js.map

package/dist/api/foundation/index.d.ts

@@ -9,4 +9,7 @@ export { type ResultJSON, type DataColumn, type DataArrayOrRecord, Result, DataA
 export { type WriteStream, DataWriter, JSONWriter, CSVWriter } from './writers';
 export { Runtime, ConnectionRuntime, SingleConnectionRuntime, ModelMaterializer, QueryMaterializer, PreparedResultMaterializer, ExploreMaterializer, } from './runtime';
 export { Manifest, MalloyConfig } from './config';
+export type { Overlay, ConfigOverlays } from './config_overlays';
+export { envOverlay, contextOverlay, defaultConfigOverlays, } from './config_overlays';
+export { discoverConfig } from './config_discover';
 export { Malloy, MalloyError, type MalloyCompileOptions, type MalloyRunOptions, } from './compile';

package/dist/api/foundation/index.js

@@ -5,7 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExploreMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.PreparedResult = exports.PreparedQuery = exports.PersistSource = exports.Model = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.AtomicField = exports.ExploreField = exports.Explore = exports.JoinRelationship = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicFieldType = exports.SourceRelationship = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentTablePath = exports.Parse = exports.InMemoryModelCache = exports.CacheManager = exports.getInvalidationKey = exports.readURL = exports.isInternalURL = exports.hashForInvalidationKey = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.EMPTY_BUILD_MANIFEST = void 0;
-exports.MalloyError = exports.Malloy = exports.MalloyConfig = exports.Manifest = void 0;
+exports.MalloyError = exports.Malloy = exports.discoverConfig = exports.defaultConfigOverlays = exports.contextOverlay = exports.envOverlay = exports.MalloyConfig = exports.Manifest = void 0;
 var types_1 = require("./types");
 Object.defineProperty(exports, "EMPTY_BUILD_MANIFEST", { enumerable: true, get: function () { return types_1.EMPTY_BUILD_MANIFEST; } });
 // URL readers and connection helpers
@@ -76,6 +76,12 @@ Object.defineProperty(exports, "ExploreMaterializer", { enumerable: true, get: f
 var config_1 = require("./config");
 Object.defineProperty(exports, "Manifest", { enumerable: true, get: function () { return config_1.Manifest; } });
 Object.defineProperty(exports, "MalloyConfig", { enumerable: true, get: function () { return config_1.MalloyConfig; } });
+var config_overlays_1 = require("./config_overlays");
+Object.defineProperty(exports, "envOverlay", { enumerable: true, get: function () { return config_overlays_1.envOverlay; } });
+Object.defineProperty(exports, "contextOverlay", { enumerable: true, get: function () { return config_overlays_1.contextOverlay; } });
+Object.defineProperty(exports, "defaultConfigOverlays", { enumerable: true, get: function () { return config_overlays_1.defaultConfigOverlays; } });
+var config_discover_1 = require("./config_discover");
+Object.defineProperty(exports, "discoverConfig", { enumerable: true, get: function () { return config_discover_1.discoverConfig; } });
 // Compile (Malloy static class)
 var compile_1 = require("./compile");
 Object.defineProperty(exports, "Malloy", { enumerable: true, get: function () { return compile_1.Malloy; } });

package/dist/api/foundation/runtime.d.ts

@@ -48,9 +48,11 @@ export declare class Runtime {
     private _cacheManager;
     private _config;
     private _buildManifest;
+    private _resolvedBuildManifestPromise;
     private _virtualMap;
-    constructor({ urlReader, connections, connection, config, eventStream, cacheManager, }: {
+    constructor({ urlReader, connections, connection, config, buildManifest, eventStream, cacheManager, }: {
         urlReader?: URLReader;
+        buildManifest?: BuildManifest;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
     } & Connectionable);
@@ -71,17 +73,47 @@ export declare class Runtime {
      */
     get eventStream(): EventStream | undefined;
     /**
-     * The build manifest for persist source substitution.
-     * When set, compiled queries automatically resolve persist sources
-     * against this manifest. Can be overridden per-query via
-     * CompileQueryOptions.buildManifest.
+     * Setter — install an explicit build manifest for persist source
+     * substitution. From this point on, compiled queries resolve persist
+     * sources against `manifest` (still overridable per-query via
+     * `CompileQueryOptions.buildManifest`). Pass `undefined` to clear.
      *
-     * When constructed with a MalloyConfig, falls through to
-     * config.manifest.buildManifest (a live reference — builder
-     * mutations are visible automatically).
+     * This wins over the auto-read path: an explicit value here takes
+     * precedence over whatever `config.manifestURL` would have resolved
+     * to. Setting also drops any cached auto-read promise so a subsequent
+     * compile sees the new value rather than a stale soft-miss.
+     *
+     * No getter is provided — call `_resolveBuildManifest()` to materialize
+     * the value the next compile will actually use (explicit > auto-read >
+     * undefined).
      */
-    get buildManifest(): BuildManifest | undefined;
     set buildManifest(manifest: BuildManifest | undefined);
+    /**
+     * Resolve the build manifest for the next compile. Called from inside
+     * the async query-compile path (`QueryMaterializer.loadPreparedResult`).
+     *
+     * Precedence:
+     *   1. Explicit `_buildManifest` (from constructor option or setter) → use it.
+     *   2. `config.manifestURL` present → lazily read it via `_urlReader`,
+     *      parse as JSON, cache the promise.
+     *      - Read failure (file not present, permission denied, etc.) →
+     *        soft miss to `undefined`. The common "no manifest yet" case
+     *        for projects that don't use persistence.
+     *      - File present but unparseable → return `{entries: {}, loadError}`
+     *        instead of `undefined`. Non-strict compiles still fall through
+     *        to inline SQL (entries is empty), but strict compiles can
+     *        include the load error in their "not found in manifest" throw,
+     *        so the user sees *why* the manifest looks empty.
+     *   3. No URL → `undefined`.
+     *
+     * The cached promise means concurrent compiles share one IO round-trip;
+     * `buildManifest = ...` (setter) clears the cache so subsequent compiles
+     * see the new value.
+     *
+     * @internal Accessed from the Materializer classes in this file. Not part
+     * of the public API — the leading underscore + `@internal` marks intent.
+     */
+    _resolveBuildManifest(): Promise<BuildManifest | undefined>;
     /**
      * The virtual map for virtual source resolution.
      * When set, compiled queries automatically resolve virtual sources
@@ -93,6 +125,19 @@ export declare class Runtime {
      */
     get virtualMap(): VirtualMap | undefined;
     set virtualMap(map: VirtualMap | undefined);
+    /**
+     * Notify every connection this runtime's config has handed out that it
+     * is time to release its resources (pools, sockets, file handles,
+     * in-process databases). A no-op for runtimes constructed without a
+     * MalloyConfig — in that case the caller owns the connections they
+     * passed in and is responsible for closing them.
+     *
+     * The expected contract is one MalloyConfig per Runtime. Long-running
+     * hosts (Publisher, a VS Code extension tearing down a project) should
+     * call this when a runtime goes out of scope; one-shot CLIs can skip it
+     * and let process exit clean up.
+     */
+    releaseConnections(): Promise<void>;
     /**
      * Load a Malloy model by URL or contents.
      *

package/dist/api/foundation/runtime.js

@@ -46,7 +46,7 @@ class FluentState {
  * An environment for compiling and running Malloy queries.
  */
 class Runtime {
-    constructor({ urlReader, connections, connection, config, eventStream, cacheManager, }) {
+    constructor({ urlReader, connections, connection, config, buildManifest, eventStream, cacheManager, }) {
         this.isTestRuntime = false;
         if (config !== undefined) {
             this._config = config;
@@ -65,6 +65,7 @@ class Runtime {
         }
         this._urlReader = urlReader;
         this._connections = connections;
+        this._buildManifest = buildManifest;
         this._eventStream = eventStream;
         this._cacheManager = cacheManager;
     }
@@ -93,21 +94,87 @@ class Runtime {
         return this._eventStream;
     }
     /**
-     * The build manifest for persist source substitution.
-     * When set, compiled queries automatically resolve persist sources
-     * against this manifest. Can be overridden per-query via
-     * CompileQueryOptions.buildManifest.
+     * Setter — install an explicit build manifest for persist source
+     * substitution. From this point on, compiled queries resolve persist
+     * sources against `manifest` (still overridable per-query via
+     * `CompileQueryOptions.buildManifest`). Pass `undefined` to clear.
      *
-     * When constructed with a MalloyConfig, falls through to
-     * config.manifest.buildManifest (a live reference — builder
-     * mutations are visible automatically).
+     * This wins over the auto-read path: an explicit value here takes
+     * precedence over whatever `config.manifestURL` would have resolved
+     * to. Setting also drops any cached auto-read promise so a subsequent
+     * compile sees the new value rather than a stale soft-miss.
+     *
+     * No getter is provided — call `_resolveBuildManifest()` to materialize
+     * the value the next compile will actually use (explicit > auto-read >
+     * undefined).
      */
-    get buildManifest() {
-        var _a, _b;
-        return (_a = this._buildManifest) !== null && _a !== void 0 ? _a : (_b = this._config) === null || _b === void 0 ? void 0 : _b.manifest.buildManifest;
-    }
     set buildManifest(manifest) {
         this._buildManifest = manifest;
+        this._resolvedBuildManifestPromise = undefined;
+    }
+    /**
+     * Resolve the build manifest for the next compile. Called from inside
+     * the async query-compile path (`QueryMaterializer.loadPreparedResult`).
+     *
+     * Precedence:
+     *   1. Explicit `_buildManifest` (from constructor option or setter) → use it.
+     *   2. `config.manifestURL` present → lazily read it via `_urlReader`,
+     *      parse as JSON, cache the promise.
+     *      - Read failure (file not present, permission denied, etc.) →
+     *        soft miss to `undefined`. The common "no manifest yet" case
+     *        for projects that don't use persistence.
+     *      - File present but unparseable → return `{entries: {}, loadError}`
+     *        instead of `undefined`. Non-strict compiles still fall through
+     *        to inline SQL (entries is empty), but strict compiles can
+     *        include the load error in their "not found in manifest" throw,
+     *        so the user sees *why* the manifest looks empty.
+     *   3. No URL → `undefined`.
+     *
+     * The cached promise means concurrent compiles share one IO round-trip;
+     * `buildManifest = ...` (setter) clears the cache so subsequent compiles
+     * see the new value.
+     *
+     * @internal Accessed from the Materializer classes in this file. Not part
+     * of the public API — the leading underscore + `@internal` marks intent.
+     */
+    _resolveBuildManifest() {
+        var _a;
+        if (this._buildManifest) {
+            return Promise.resolve(this._buildManifest);
+        }
+        const url = (_a = this._config) === null || _a === void 0 ? void 0 : _a.manifestURL;
+        if (!url)
+            return Promise.resolve(undefined);
+        if (!this._resolvedBuildManifestPromise) {
+            this._resolvedBuildManifestPromise = (async () => {
+                let text;
+                try {
+                    const result = await this._urlReader.readURL(url);
+                    text = typeof result === 'string' ? result : result.contents;
+                }
+                catch {
+                    // Read failure (no file, permission, etc.) — treat as "no
+                    // manifest, no substitution." Strict mode is silently inactive
+                    // here, matching the soloist case where there's nothing to
+                    // strict-check against.
+                    return undefined;
+                }
+                try {
+                    return JSON.parse(text);
+                }
+                catch (e) {
+                    // File was present but couldn't be parsed. Return an empty
+                    // manifest carrying the load error so a strict-mode compile can
+                    // surface the real reason in its throw.
+                    const msg = e instanceof Error ? e.message : String(e);
+                    return {
+                        entries: {},
+                        loadError: `Manifest file at ${url.toString()} could not be parsed: ${msg}`,
+                    };
+                }
+            })();
+        }
+        return this._resolvedBuildManifestPromise;
     }
     /**
      * The virtual map for virtual source resolution.
@@ -125,6 +192,22 @@ class Runtime {
     set virtualMap(map) {
         this._virtualMap = map;
     }
+    /**
+     * Notify every connection this runtime's config has handed out that it
+     * is time to release its resources (pools, sockets, file handles,
+     * in-process databases). A no-op for runtimes constructed without a
+     * MalloyConfig — in that case the caller owns the connections they
+     * passed in and is responsible for closing them.
+     *
+     * The expected contract is one MalloyConfig per Runtime. Long-running
+     * hosts (Publisher, a VS Code extension tearing down a project) should
+     * call this when a runtime goes out of scope; one-shot CLIs can skip it
+     * and let process exit clean up.
+     */
+    async releaseConnections() {
+        var _a;
+        await ((_a = this._config) === null || _a === void 0 ? void 0 : _a.releaseConnections());
+    }
     /**
      * Load a Malloy model by URL or contents.
      *
@@ -598,10 +681,11 @@ class QueryMaterializer extends FluentState {
                 ...this.compileQueryOptions,
                 ...options,
             };
-            // Use manifest from options if provided, otherwise fall back to Runtime's manifest.
+            // Use manifest from options if provided, otherwise fall back to
+            // Runtime's manifest (explicit or lazily-read from config.manifestURL).
             // Pass EMPTY_BUILD_MANIFEST in options to explicitly suppress manifest substitution.
             const explicitManifest = mergedOptions.buildManifest !== undefined;
-            let buildManifest = (_a = mergedOptions.buildManifest) !== null && _a !== void 0 ? _a : this.runtime.buildManifest;
+            let buildManifest = (_a = mergedOptions.buildManifest) !== null && _a !== void 0 ? _a : (await this.runtime._resolveBuildManifest());
             // If we have a manifest with entries, compute connectionDigests for lookups.
             // TODO: This is inefficient - we call getBuildPlan just to find connection names.
             // Consider adding a listConnections() method to LookupConnection, or caching this.

package/dist/connection/registry.d.ts

@@ -9,13 +9,22 @@ export type ConnectionTypeFactory = (config: ConnectionConfig) => Promise<Connec
 export type ConnectionPropertyType = 'string' | 'number' | 'boolean' | 'password' | 'secret' | 'file' | 'json' | 'text';
 /**
  * Describes a single configuration property for a connection type.
+ *
+ * `default` accepts either a literal value or a single-key object that names an
+ * overlay source: e.g. `{config: 'rootDirectory'}` or `{env: 'HOME'}`. Defaults
+ * apply uniformly to every connection entry that doesn't specify the property —
+ * both user-listed entries and entries fabricated by `includeDefaultConnections`.
+ * Reference-shaped defaults are resolved through the same config overlays as
+ * inline references.
  */
 export interface ConnectionPropertyDefinition {
     name: string;
     displayName: string;
     type: ConnectionPropertyType;
     optional?: true;
-    default?: string;
+    default?: string | number | boolean | {
+        [source: string]: string | string[];
+    };
     description?: string;
     /** For type 'file': extension filters for picker dialogs. */
     fileFilters?: Record<string, string[]>;
@@ -28,12 +37,6 @@ export interface ConnectionTypeDef {
     factory: ConnectionTypeFactory;
     properties: ConnectionPropertyDefinition[];
 }
-/**
- * An environment variable reference in a config file.
- */
-export type ValueRef = {
-    env: string;
-};
 /**
  * A JSON-compatible value for structured config properties (e.g. SSL options).
  */
@@ -41,25 +44,13 @@ export type JsonConfigValue = string | number | boolean | null | JsonConfigValue
     [key: string]: JsonConfigValue;
 };
 /**
- * The type of a config property value: a literal, an env reference, a JSON
- * object, or undefined.
- */
-export type ConfigValue = string | number | boolean | ValueRef | JsonConfigValue | undefined;
-/**
- * Type guard for ValueRef.
- */
-export declare function isValueRef(value: unknown): value is ValueRef;
-/**
- * Resolve a ValueRef to a string by looking up the environment variable.
- * Returns undefined if the env var is not set.
- */
-export declare function resolveValue(vr: ValueRef): string | undefined;
-/**
- * A single connection entry in a JSON config.
+ * A single connection entry passed to `createConnectionsFromConfig`. All
+ * values here are already fully resolved — overlay references are expanded
+ * by the config compiler/resolver before the registry ever sees them.
  */
 export interface ConnectionConfigEntry {
     is: string;
-    [key: string]: ConfigValue;
+    [key: string]: unknown;
 }
 /**
  * Type guard for ConnectionConfigEntry.

package/dist/connection/registry.js

@@ -4,8 +4,6 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValueRef = isValueRef;
-exports.resolveValue = resolveValue;
 exports.isConnectionConfigEntry = isConnectionConfigEntry;
 exports.registerConnectionType = registerConnectionType;
 exports.getConnectionProperties = getConnectionProperties;
@@ -14,24 +12,6 @@ exports.getRegisteredConnectionTypes = getRegisteredConnectionTypes;
 exports.readConnectionsConfig = readConnectionsConfig;
 exports.writeConnectionsConfig = writeConnectionsConfig;
 exports.createConnectionsFromConfig = createConnectionsFromConfig;
-/**
- * Type guard for ValueRef.
- */
-function isValueRef(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.keys(value).length === 1 &&
-        'env' in value &&
-        typeof value.env === 'string');
-}
-/**
- * Resolve a ValueRef to a string by looking up the environment variable.
- * Returns undefined if the env var is not set.
- */
-function resolveValue(vr) {
-    return process.env[vr.env];
-}
 /**
  * Type guard for ConnectionConfigEntry.
  */
@@ -126,21 +106,16 @@ function createConnectionsFromConfig(config, onConnectionCreated) {
                 throw new Error(`No registered connection type "${entry.is}" for connection "${connectionName}". ` +
                     'Did you forget to import the connection package?');
             }
-            const jsonKeys = new Set(typeDef.properties.filter(p => p.type === 'json').map(p => p.name));
+            // Values are already resolved — the config compiler/resolver handles
+            // overlay references, property defaults, and entry fabrication via
+            // `includeDefaultConnections`. The registry's only job is to hand them
+            // to the factory.
             const connConfig = { name: connectionName };
             for (const [key, value] of Object.entries(entry)) {
                 if (key === 'is')
                     continue;
                 if (value !== undefined && value !== null) {
-                    if (!jsonKeys.has(key) && isValueRef(value)) {
-                        const resolved = resolveValue(value);
-                        if (resolved !== undefined) {
-                            connConfig[key] = resolved;
-                        }
-                    }
-                    else {
-                        connConfig[key] = value;
-                    }
+                    connConfig[key] = value;
                 }
             }
             const connection = await typeDef.factory(connConfig);

package/dist/index.d.ts

@@ -4,13 +4,14 @@ export type { QueryRecord, StructDef, TableSourceDef, SQLSourceDef, SourceDef, J
 export { isSourceDef, isAtomic, isBasicAtomic, isCompoundArrayData, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } from './model';
 export { malloyToQuery, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
-export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, Manifest, MalloyConfig, } from './api/foundation';
+export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, Manifest, MalloyConfig, envOverlay, contextOverlay, defaultConfigOverlays, discoverConfig, } from './api/foundation';
 export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, } from './api/foundation';
+export type { Overlay, ConfigOverlays } from './api/foundation';
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionParameterValue, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
-export { registerConnectionType, getConnectionProperties, getConnectionTypeDisplayName, getRegisteredConnectionTypes, createConnectionsFromConfig, isValueRef, resolveValue, } from './connection/registry';
-export type { ConnectionTypeFactory, ConnectionPropertyType, ConnectionPropertyDefinition, ConnectionTypeDef, ConnectionConfigEntry, ConnectionsConfig, ConfigValue, JsonConfigValue, ValueRef, ManagedConnectionLookup, } from './connection/registry';
+export { registerConnectionType, getConnectionProperties, getConnectionTypeDisplayName, getRegisteredConnectionTypes, createConnectionsFromConfig, } from './connection/registry';
+export type { ConnectionTypeFactory, ConnectionPropertyType, ConnectionPropertyDefinition, ConnectionTypeDef, ConnectionConfigEntry, ConnectionsConfig, JsonConfigValue, ManagedConnectionLookup, } from './connection/registry';
 export { toAsyncGenerator } from './connection_utils';
 export { modelDefToModelInfo, sourceDefToSourceInfo } from './to_stable';
 export * as API from './api';