@malloydata/malloy 0.0.372 → 0.0.374

package/dist/api/foundation/config.js

@@ -6,54 +6,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MalloyConfig = exports.Manifest = void 0;
 const registry_1 = require("../../connection/registry");
-const DEFAULT_MANIFEST_PATH = 'MANIFESTS';
-const MANIFEST_FILENAME = 'malloy-manifest.json';
+const config_compile_1 = require("./config_compile");
+const config_resolve_1 = require("./config_resolve");
+const config_overlays_1 = require("./config_overlays");
 /**
  * In-memory manifest store. Reads, updates, and serializes manifest data.
  *
- * Always valid — starts empty, call load() to populate from a file.
- * The BuildManifest object returned by `buildManifest` is stable: load()
- * and update() mutate the same entries object, so any reference obtained
- * via `buildManifest` stays current without re-assignment.
+ * Always valid — starts empty. Populate by calling `loadText(jsonText)` with
+ * the manifest file contents, which the caller reads themselves (typically
+ * through a `URLReader` they already have). The `Manifest` class deliberately
+ * does no IO — it exists so that applications that want to build or mutate
+ * manifest state have a typed handle with a stable `buildManifest` reference.
  *
- * The `strict` flag controls what happens when a persist source's BuildID
- * is not found in the manifest. When strict, the compiler throws an error
- * instead of falling through to inline SQL. The flag is loaded from the
- * manifest file and can be overridden by the application before creating
- * a Runtime.
+ * The `BuildManifest` returned by `buildManifest` is stable: `loadText()` and
+ * `update()` mutate the same entries object, so any reference obtained via
+ * `buildManifest` stays current without re-assignment.
+ *
+ * The `strict` flag controls what happens when a persist source's BuildID is
+ * not found in the manifest. When strict, the compiler throws an error
+ * instead of falling through to inline SQL. Loaded from the manifest file by
+ * `loadText()`; applications may override it at any time.
  */
 class Manifest {
-    constructor(urlReader) {
+    constructor() {
         this._manifest = { entries: {}, strict: false };
         this._touched = new Set();
-        this._urlReader = urlReader;
-    }
-    /**
-     * Load manifest data from a manifest root directory.
-     * Reads `<manifestRoot>/malloy-manifest.json` via the URLReader.
-     * Replaces any existing data. If the file doesn't exist or no URLReader
-     * is available, clears to empty.
-     */
-    async load(manifestRoot) {
-        this._clearEntries();
-        this._touched.clear();
-        this._manifest.strict = false;
-        if (!this._urlReader)
-            return;
-        const dir = manifestRoot.toString().endsWith('/')
-            ? manifestRoot.toString()
-            : manifestRoot.toString() + '/';
-        const manifestURL = new URL(MANIFEST_FILENAME, dir);
-        let contents;
-        try {
-            const result = await this._urlReader.readURL(manifestURL);
-            contents = typeof result === 'string' ? result : result.contents;
-        }
-        catch {
-            // No manifest file — stay empty
-            return;
-        }
-        this._loadParsed(JSON.parse(contents));
     }
     /**
      * Load manifest data from a JSON string.
@@ -66,9 +43,9 @@ class Manifest {
         this._loadParsed(JSON.parse(jsonText));
     }
     /**
-     * The live BuildManifest. This is a stable reference — load() and update()
-     * mutate the same object, so passing this to a Runtime means the Runtime
-     * always sees current data including the strict flag.
+     * The live BuildManifest. This is a stable reference — `loadText()` and
+     * `update()` mutate the same object, so passing this to a Runtime means
+     * the Runtime always sees current data including the strict flag.
      */
     get buildManifest() {
         return this._manifest;
@@ -133,369 +110,233 @@ class Manifest {
 }
 exports.Manifest = Manifest;
 /**
- * Loads and holds a Malloy project configuration (connections + manifest +
- * virtualMap). Pass directly to Runtime — everything flows automatically.
+ * A resolved Malloy runtime configuration. The constructor takes either a
+ * JSON string (legacy/compat) or a POJO plus an optional `ConfigOverlays`
+ * dict, compiles the input into a typed tree, resolves all overlay
+ * references, and builds the connection lookup via the connection registry.
  *
- *   // From a URL — reads config + manifest via URLReader
- *   const config = new MalloyConfig(urlReader, configURL);
- *   await config.load();
+ * After construction:
+ *   - `connections` — the `LookupConnection` runtime consumes. Starts as the
+ *     lookup created from the resolved connections; `wrapConnections()` replaces
+ *     it with a wrapped version for host-specific behavior.
+ *   - `virtualMap` — extracted from the POJO as-is.
+ *   - `manifestPath` — extracted from the POJO as-is (the raw string).
+ *   - `manifestURL` — resolved URL of `malloy-manifest.json`, computed from
+ *     `manifestPath` + the `configURL` carried on the `config` overlay (if
+ *     any). `undefined` when no `configURL` is available. Runtime uses this
+ *     to lazily read the manifest on the first persistence query. Builders
+ *     that want to construct or mutate manifest state use the standalone
+ *     `Manifest` class directly — they don't go through MalloyConfig.
+ *   - `log` — validation warnings and overlay-resolution warnings.
  *
- *   // From text you already have
- *   const config = new MalloyConfig(configText);
+ * Typical usage:
  *
- *   // Either way, pass to Runtime — connections, buildManifest, virtualMap
- *   // all come from the config. No manual wiring needed.
+ *   // From a pre-loaded POJO (e.g. from `discoverConfig` or Publisher):
+ *   const config = new MalloyConfig(pojo);
  *   const runtime = new Runtime({config, urlReader});
  *
- * To override specific fields, mutate the config before passing:
- *   config.connectionMap = myCustomConnections;
+ *   // From a JSON string:
+ *   const config = new MalloyConfig(configText);
+ *
+ *   // With host-supplied overlays (local hosts after discovery):
+ *   const config = new MalloyConfig(pojo, {
+ *     config: contextOverlay({rootDirectory: ceilingURL}),
+ *   });
+ *
+ *   // Wrap the connection lookup for host-specific behavior:
+ *   config.wrapConnections(base => name => base(name) ?? fallback(name));
+ *
+ * The old async `new MalloyConfig(urlReader, configURL)` form has been
+ * removed. Callers that need to load from a URL should pre-load via
+ * `urlReader.readURL()` / `JSON.parse()` and pass the POJO, or use the
+ * sync string form after reading the file.
  */
 class MalloyConfig {
-    constructor(urlReaderOrText, configURL) {
-        this._log = [];
-        if (typeof urlReaderOrText === 'string') {
-            const { config, log } = parseConfigText(urlReaderOrText);
-            this._data = config;
-            this._log = log;
-            this._connectionMap = this._data.connections
-                ? { ...this._data.connections }
-                : undefined;
-            this._manifest = new Manifest();
+    constructor(sourceOrPojo, overlays) {
+        const log = [];
+        // Normalize input to a POJO.
+        let pojo;
+        if (typeof sourceOrPojo === 'string') {
+            try {
+                pojo = JSON.parse(sourceOrPojo);
+            }
+            catch (e) {
+                log.push({
+                    message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`,
+                    severity: 'error',
+                    code: 'config-validation',
+                });
+                pojo = {};
+            }
         }
         else {
-            this._urlReader = urlReaderOrText;
-            this._configURL = configURL;
-            this._manifest = new Manifest(urlReaderOrText);
-        }
-    }
-    /**
-     * Load everything: parse config file, then load the default manifest.
-     * No-op if created from text.
-     */
-    async load() {
-        var _a, _b;
-        await this.loadConfig();
-        if (this._configURL) {
-            const manifestPath = (_b = (_a = this._data) === null || _a === void 0 ? void 0 : _a.manifestPath) !== null && _b !== void 0 ? _b : DEFAULT_MANIFEST_PATH;
-            const manifestRoot = new URL(manifestPath, this._configURL);
-            await this._manifest.load(manifestRoot);
+            pojo = sourceOrPojo;
         }
+        // Compile → typed tree + validation warnings.
+        const compiled = (0, config_compile_1.compileConfig)(pojo);
+        log.push(...compiled.log);
+        // Resolve against the merged config overlays. Entries from the passed
+        // overlays replace same-named entries in the defaults; anything new
+        // is added.
+        const mergedOverlays = {
+            ...(0, config_overlays_1.defaultConfigOverlays)(),
+            ...overlays,
+        };
+        const resolved = (0, config_resolve_1.resolveConfig)(compiled.compiled, mergedOverlays, log);
+        // Hand fully-resolved connection entries to the registry — factories
+        // never see raw references.
+        this._managedLookup = (0, registry_1.createConnectionsFromConfig)({
+            connections: resolved.connections,
+        });
+        this._connections = this._managedLookup;
+        this._overlays = mergedOverlays;
+        this.virtualMap = toVirtualMap(resolved.virtualMap);
+        this.manifestPath = resolved.manifestPath;
+        this.manifestURL = computeManifestURL(resolved.manifestPath, mergedOverlays);
+        this.log = log;
     }
     /**
-     * Load only the config file. Does not load the manifest.
-     * No-op if created from text.
-     */
-    async loadConfig() {
-        if (!this._urlReader || !this._configURL)
-            return;
-        const result = await this._urlReader.readURL(new URL(this._configURL));
-        const contents = typeof result === 'string' ? result : result.contents;
-        const parsed = parseConfigText(contents);
-        this._data = parsed.config;
-        this._log = parsed.log;
-        this._connectionMap = this._data.connections
-            ? { ...this._data.connections }
-            : undefined;
-    }
-    /**
-     * The parsed config data. Undefined if created from URL and not yet loaded.
+     * The live `LookupConnection` consumed by Runtime. Stable until
+     * `wrapConnections()` is called; after that, returns the wrapped lookup.
      */
-    get data() {
-        return this._data;
+    get connections() {
+        return this._connections;
     }
     /**
-     * The active connection entries. Set this to override which connections
-     * are used before constructing a Runtime.
+     * Wrap the current connection lookup with a host-supplied wrapper.
+     * Mutates in place — subsequent `connections` accesses return the new
+     * wrapped lookup. Runtime never needs to know whether wrapping happened.
+     *
+     * Typical uses:
+     *   - VS Code layers settings + defaults below the config lookup
+     *   - Publisher attaches session-specific behavior to resolved connections
      */
-    get connectionMap() {
-        return this._connectionMap;
-    }
-    set connectionMap(map) {
-        this._connectionMap = map;
-        // Invalidate cached managed lookup — new map means new connections
-        this._managedLookup = undefined;
+    wrapConnections(wrapper) {
+        this._connections = wrapper(this._connections);
     }
     /**
-     * A LookupConnection built from the current connectionMap via the
-     * connection type registry. The result is cached — repeated access
-     * returns the same object (and the same underlying connections).
+     * Notify every connection this config has handed out that it is time to
+     * release its resources, then drop them from the internal cache.
      *
-     * If `connectionLookup` has been set, returns the override instead.
+     * Most callers should use `Runtime.releaseConnections()` instead — the
+     * expected contract is one MalloyConfig per Runtime, and the runtime is
+     * the natural handle for lifecycle. This method exists because Runtime
+     * forwards to it, and for the rare case of a MalloyConfig constructed
+     * without an accompanying Runtime.
      *
-     * Changing `connectionMap` invalidates the cache; the next access
-     * creates a fresh ManagedConnectionLookup.
-     */
-    get connections() {
-        if (this._connectionLookupOverride) {
-            return this._connectionLookupOverride;
-        }
-        if (!this._connectionMap) {
-            throw new Error('Config not loaded. Call load() or loadConfig() first.');
-        }
-        if (!this._managedLookup) {
-            this._managedLookup = (0, registry_1.createConnectionsFromConfig)({ connections: this._connectionMap }, this._onConnectionCreated);
-        }
-        return this._managedLookup;
-    }
-    /**
-     * Override the connection lookup entirely. When set, the `connections`
-     * getter returns this instead of building from `connectionMap`.
-     * Use this when you need to merge config connections with other sources.
-     */
-    get connectionLookup() {
-        return this._connectionLookupOverride;
-    }
-    set connectionLookup(lookup) {
-        this._connectionLookupOverride = lookup;
-    }
-    /**
-     * Callback invoked once per connection immediately after factory creation.
-     * Use for post-creation setup (e.g., registering WASM file handlers).
-     * Must be set before the first connection is looked up.
-     */
-    set onConnectionCreated(cb) {
-        this._onConnectionCreated = cb;
-    }
-    /**
-     * Close all connections created by this config's internal managed lookup.
-     * Does nothing if connections were overridden via `connectionLookup`.
-     */
-    async close() {
-        if (this._managedLookup) {
-            await this._managedLookup.close();
-            this._managedLookup = undefined;
-        }
-    }
-    /**
-     * The Manifest object. Always exists, may be empty if not yet loaded.
-     */
-    get manifest() {
-        return this._manifest;
-    }
-    /**
-     * The VirtualMap parsed from config, if present.
+     * MalloyConfig does not own any connection resources itself — pools,
+     * sockets, file handles, and in-process databases all live inside the
+     * individual Connection objects. What the managed lookup owns is a cache
+     * of `name → Connection` populated lazily as callers request connections.
+     * This method walks that cache and calls `Connection.close()` on each
+     * entry, which is the signal each connection uses to shut down whatever
+     * resources it actually holds.
+     *
+     * Connections that were never looked up were never constructed and have
+     * nothing to release; they are skipped. Wrapping lookups installed via
+     * `wrapConnections()` do not interfere — the managed lookup under the
+     * wrap is the one holding the cache.
      */
-    get virtualMap() {
-        var _a;
-        return (_a = this._data) === null || _a === void 0 ? void 0 : _a.virtualMap;
+    async releaseConnections() {
+        await this._managedLookup.close();
     }
     /**
-     * Errors and warnings from parsing and validating the config.
-     * Includes JSON parse errors (severity 'error') and schema validation
-     * warnings (severity 'warn') such as unknown keys, unknown connection
-     * types, wrong value types, and missing environment variables.
+     * Query a value from the overlays used to resolve this config.
+     *
+     * Returns the value the named overlay produces for the given path,
+     * or `undefined` if the overlay doesn't exist or the path has no value.
+     *
+     *   config.readOverlay('config', 'rootDirectory')
+     *   config.readOverlay('config', 'configURL')
+     *   config.readOverlay('env', 'PG_PASSWORD')
      */
-    get log() {
-        return this._log;
+    readOverlay(overlayName, ...path) {
+        var _a, _b;
+        return (_b = (_a = this._overlays)[overlayName]) === null || _b === void 0 ? void 0 : _b.call(_a, path);
     }
 }
 exports.MalloyConfig = MalloyConfig;
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Default directory (relative to the config file) where the manifest lives
+ * when `manifestPath` is not explicitly set. ALL CAPS signals a generated
+ * artifact, not a hand-authored file. No dot prefix — visible and
+ * discoverable in `ls`.
+ */
+const DEFAULT_MANIFEST_PATH = 'MANIFESTS';
 /**
- * Parse a config JSON string into a MalloyProjectConfig.
- * Invalid connection entries (missing `is`) are silently dropped.
- * Returns the processed config and validation log.
+ * The filename inside the manifest directory.
  */
-function parseConfigText(jsonText) {
-    let parsed;
+const MANIFEST_FILENAME = 'malloy-manifest.json';
+/**
+ * Compute the resolved URL of the manifest file from the raw `manifestPath`
+ * string and the merged overlays (which may carry a `configURL`).
+ *
+ * Rules:
+ *   - If there's no `configURL` in the `config` overlay → undefined.
+ *   - `manifestPath` defaults to `'MANIFESTS'`.
+ *   - `new URL(manifestPath, configURL)` handles three shapes uniformly:
+ *       "MANIFESTS"               → relative to configURL's directory
+ *       "../shared/MANIFESTS"     → parent-relative
+ *       "/project/malloy/MANIFESTS" → absolute path within configURL's scheme
+ *       "file:///elsewhere/stuff" → full URL, ignores configURL base
+ *   - A trailing slash is forced onto the directory portion so that the
+ *     final `new URL(MANIFEST_FILENAME, dir)` joins correctly.
+ */
+function computeManifestURL(manifestPath, overlays) {
+    const configOverlay = overlays['config'];
+    const configURLValue = configOverlay === null || configOverlay === void 0 ? void 0 : configOverlay(['configURL']);
+    if (typeof configURLValue !== 'string')
+        return undefined;
+    let configURL;
     try {
-        parsed = JSON.parse(jsonText);
+        configURL = new URL(configURLValue);
     }
-    catch (e) {
-        return {
-            config: {},
-            log: [
-                {
-                    message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`,
-                    severity: 'error',
-                    code: 'config-validation',
-                },
-            ],
-        };
+    catch {
+        return undefined;
     }
-    if (!isRecord(parsed)) {
-        return {
-            config: {},
-            log: [
-                {
-                    message: 'config is not a JSON object',
-                    severity: 'error',
-                    code: 'config-validation',
-                },
-            ],
-        };
+    const path = manifestPath !== null && manifestPath !== void 0 ? manifestPath : DEFAULT_MANIFEST_PATH;
+    let manifestRoot;
+    try {
+        manifestRoot = new URL(path, configURL);
     }
-    const rawConnections = parsed['connections'];
-    const connectionEntries = Object.entries(isRecord(rawConnections) ? rawConnections : {}).filter((entry) => (0, registry_1.isConnectionConfigEntry)(entry[1]));
-    const connections = Object.fromEntries(connectionEntries);
-    const result = { ...parsed, connections };
-    const virtualMap = parsed['virtualMap'];
-    if (virtualMap &&
-        typeof virtualMap === 'object' &&
-        !Array.isArray(virtualMap)) {
-        const outer = new Map();
-        for (const [connName, inner] of Object.entries(virtualMap)) {
-            if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
-                const innerMap = new Map();
-                for (const [virtualName, tablePath] of Object.entries(inner)) {
-                    if (typeof tablePath === 'string') {
-                        innerMap.set(virtualName, tablePath);
-                    }
-                }
-                outer.set(connName, innerMap);
-            }
-        }
-        result.virtualMap = outer;
+    catch {
+        return undefined;
     }
-    return { config: result, log: validateConfig(parsed) };
-}
-const KNOWN_TOP_LEVEL_KEYS = new Set([
-    'connections',
-    'manifestPath',
-    'virtualMap',
-]);
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isBuildManifestEntry(value) {
-    return isRecord(value) && typeof value['tableName'] === 'string';
-}
-function makeWarning(path, message) {
-    return {
-        message: `${path}: ${message}`,
-        severity: 'warn',
-        code: 'config-validation',
-    };
+    const asString = manifestRoot.toString();
+    const dirURL = asString.endsWith('/')
+        ? manifestRoot
+        : new URL(asString + '/');
+    return new URL(MANIFEST_FILENAME, dirURL);
 }
 /**
- * Validate a parsed config object against the connection type registry.
- * Returns LogMessage[] — does not throw.
+ * Convert the raw virtualMap POJO shape (a dict of dicts of strings) into
+ * the runtime Map-of-Maps representation that Runtime consumes.
  */
-function validateConfig(data) {
-    const log = [];
-    for (const key of Object.keys(data)) {
-        if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
-            const suggestion = closestMatch(key, [...KNOWN_TOP_LEVEL_KEYS]);
-            const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
-            log.push(makeWarning(key, `unknown config key "${key}"${hint}`));
-        }
-    }
-    if (data['manifestPath'] !== undefined &&
-        typeof data['manifestPath'] !== 'string') {
-        log.push(makeWarning('manifestPath', '"manifestPath" should be a string'));
-    }
-    const connections = data['connections'];
-    if (connections === undefined)
-        return log;
-    if (!isRecord(connections)) {
-        log.push(makeWarning('connections', '"connections" should be an object'));
-        return log;
-    }
-    const registeredTypes = new Set((0, registry_1.getRegisteredConnectionTypes)());
-    for (const [name, rawEntry] of Object.entries(connections)) {
-        const prefix = `connections.${name}`;
-        if (!isRecord(rawEntry)) {
-            log.push(makeWarning(prefix, 'should be an object'));
-            continue;
-        }
-        if (!rawEntry['is']) {
-            log.push(makeWarning(prefix, 'missing required "is" field (connection type)'));
-            continue;
-        }
-        if (typeof rawEntry['is'] !== 'string') {
-            log.push(makeWarning(`${prefix}.is`, '"is" should be a string'));
-            continue;
-        }
-        const typeName = rawEntry['is'];
-        if (!registeredTypes.has(typeName)) {
-            const suggestion = closestMatch(typeName, [...registeredTypes]);
-            const hint = suggestion ? ` Did you mean "${suggestion}"?` : '';
-            log.push(makeWarning(`${prefix}.is`, `unknown connection type "${typeName}".${hint} Available types: ${[...registeredTypes].join(', ')}`));
-            continue;
-        }
-        const props = (0, registry_1.getConnectionProperties)(typeName);
-        if (!props)
+function toVirtualMap(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const outer = new Map();
+    for (const [connName, inner] of Object.entries(raw)) {
+        if (!isRecord(inner))
             continue;
-        const knownProps = new Map(props.map(p => [p.name, p]));
-        for (const [key, value] of Object.entries(rawEntry)) {
-            if (key === 'is')
-                continue;
-            const propDef = knownProps.get(key);
-            if (!propDef) {
-                const suggestion = closestMatch(key, [...knownProps.keys()]);
-                const hint = suggestion ? `. Did you mean "${suggestion}"?` : '';
-                log.push(makeWarning(`${prefix}.${key}`, `unknown property "${key}" for connection type "${typeName}"${hint}`));
-                continue;
-            }
-            // For env var references on non-json props, check the variable exists.
-            if (propDef.type !== 'json' && (0, registry_1.isValueRef)(value)) {
-                const env = value.env;
-                if (process.env[env] === undefined) {
-                    log.push(makeWarning(`${prefix}.${key}`, `environment variable "${env}" is not set`));
-                }
-                continue;
-            }
-            const typeError = checkValueType(value, propDef.type);
-            if (typeError) {
-                log.push(makeWarning(`${prefix}.${key}`, `${typeError} (expected ${propDef.type})`));
+        const innerMap = new Map();
+        for (const [virtualName, tablePath] of Object.entries(inner)) {
+            if (typeof tablePath === 'string') {
+                innerMap.set(virtualName, tablePath);
             }
         }
+        if (innerMap.size > 0)
+            outer.set(connName, innerMap);
     }
-    return log;
+    return outer.size > 0 ? outer : undefined;
 }
-function levenshtein(a, b) {
-    const m = a.length;
-    const n = b.length;
-    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-    for (let i = 0; i <= m; i++)
-        dp[i][0] = i;
-    for (let j = 0; j <= n; j++)
-        dp[0][j] = j;
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
-        }
-    }
-    return dp[m][n];
-}
-function closestMatch(input, candidates) {
-    if (candidates.length === 0)
-        return undefined;
-    let best = candidates[0];
-    let bestDist = Infinity;
-    for (const c of candidates) {
-        const dist = levenshtein(input.toLowerCase(), c.toLowerCase());
-        if (dist < bestDist) {
-            bestDist = dist;
-            best = c;
-        }
-    }
-    const maxDist = Math.max(1, Math.floor(Math.max(input.length, best.length) / 3));
-    return bestDist <= maxDist ? best : undefined;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function checkValueType(value, expectedType) {
-    if (value === undefined || value === null)
-        return undefined;
-    switch (expectedType) {
-        case 'number':
-            if (typeof value !== 'number')
-                return `should be a number, got ${typeof value}`;
-            break;
-        case 'boolean':
-            if (typeof value !== 'boolean')
-                return `should be a boolean, got ${typeof value}`;
-            break;
-        case 'string':
-        case 'password':
-        case 'secret':
-        case 'file':
-        case 'text':
-            if (typeof value !== 'string')
-                return `should be a string, got ${typeof value}`;
-            break;
-        case 'json':
-            break;
-    }
-    return undefined;
+function isBuildManifestEntry(value) {
+    return isRecord(value) && typeof value['tableName'] === 'string';
 }
 //# sourceMappingURL=config.js.map