@malloydata/malloy 0.0.365 → 0.0.366

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

@@ -1,6 +1,7 @@
 import type { URLReader } from '../../runtime_types';
 import type { Connection, LookupConnection } from '../../connection/types';
 import type { ConnectionConfigEntry } from '../../connection/registry';
+import type { LogMessage } from '../../lang/parse-log';
 import type { BuildID, BuildManifest, BuildManifestEntry, VirtualMap } from '../../model/malloy_types';
 /**
  * The parsed contents of a malloy-config.json file.
@@ -93,6 +94,7 @@ export declare class MalloyConfig {
     private readonly _urlReader?;
     private readonly _configURL?;
     private _data;
+    private _log;
     private _connectionMap;
     private readonly _manifest;
     private _managedLookup;
@@ -157,4 +159,11 @@ export declare class MalloyConfig {
      * The VirtualMap parsed from config, if present.
      */
     get virtualMap(): VirtualMap | undefined;
+    /**
+     * 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.
+     */
+    get log(): LogMessage[];
 }

package/dist/api/foundation/config.js

@@ -123,23 +123,12 @@ class Manifest {
         }
         // New format: {entries: {...}, strict?: boolean}
         // Old format: {buildId: {tableName}, ...} (flat record, no "entries" key)
-        let entries;
-        if (parsed['entries'] && typeof parsed['entries'] === 'object') {
-            entries = parsed['entries'];
-        }
-        else {
-            // Treat as old flat-record format: every key with a tableName is an entry
-            entries = {};
-            for (const [key, val] of Object.entries(parsed)) {
-                if (key !== 'strict' &&
-                    val &&
-                    typeof val === 'object' &&
-                    'tableName' in val) {
-                    entries[key] = val;
-                }
+        const rawEntries = isRecord(parsed['entries']) ? parsed['entries'] : parsed;
+        for (const [key, val] of Object.entries(rawEntries)) {
+            if (key !== 'strict' && isBuildManifestEntry(val)) {
+                this._manifest.entries[key] = val;
             }
         }
-        Object.assign(this._manifest.entries, entries);
     }
 }
 exports.Manifest = Manifest;
@@ -163,8 +152,11 @@ exports.Manifest = Manifest;
  */
 class MalloyConfig {
     constructor(urlReaderOrText, configURL) {
+        this._log = [];
         if (typeof urlReaderOrText === 'string') {
-            this._data = parseConfigText(urlReaderOrText);
+            const { config, log } = parseConfigText(urlReaderOrText);
+            this._data = config;
+            this._log = log;
             this._connectionMap = this._data.connections
                 ? { ...this._data.connections }
                 : undefined;
@@ -198,7 +190,9 @@ class MalloyConfig {
             return;
         const result = await this._urlReader.readURL(new URL(this._configURL));
         const contents = typeof result === 'string' ? result : result.contents;
-        this._data = parseConfigText(contents);
+        const parsed = parseConfigText(contents);
+        this._data = parsed.config;
+        this._log = parsed.log;
         this._connectionMap = this._data.connections
             ? { ...this._data.connections }
             : undefined;
@@ -285,22 +279,61 @@ class MalloyConfig {
         var _a;
         return (_a = this._data) === null || _a === void 0 ? void 0 : _a.virtualMap;
     }
+    /**
+     * 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.
+     */
+    get log() {
+        return this._log;
+    }
 }
 exports.MalloyConfig = MalloyConfig;
 /**
  * Parse a config JSON string into a MalloyProjectConfig.
  * Invalid connection entries (missing `is`) are silently dropped.
+ * Returns the processed config and validation log.
  */
 function parseConfigText(jsonText) {
-    var _a;
-    const parsed = JSON.parse(jsonText);
-    const connections = Object.fromEntries(Object.entries((_a = parsed.connections) !== null && _a !== void 0 ? _a : {}).filter(([, v]) => (0, registry_1.isConnectionConfigEntry)(v)));
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch (e) {
+        return {
+            config: {},
+            log: [
+                {
+                    message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`,
+                    severity: 'error',
+                    code: 'config-validation',
+                },
+            ],
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            config: {},
+            log: [
+                {
+                    message: 'config is not a JSON object',
+                    severity: 'error',
+                    code: 'config-validation',
+                },
+            ],
+        };
+    }
+    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 };
-    if (parsed.virtualMap &&
-        typeof parsed.virtualMap === 'object' &&
-        !Array.isArray(parsed.virtualMap)) {
+    const virtualMap = parsed['virtualMap'];
+    if (virtualMap &&
+        typeof virtualMap === 'object' &&
+        !Array.isArray(virtualMap)) {
         const outer = new Map();
-        for (const [connName, inner] of Object.entries(parsed.virtualMap)) {
+        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)) {
@@ -313,6 +346,156 @@ function parseConfigText(jsonText) {
         }
         result.virtualMap = outer;
     }
-    return result;
+    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',
+    };
+}
+/**
+ * Validate a parsed config object against the connection type registry.
+ * Returns LogMessage[] — does not throw.
+ */
+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)
+            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})`));
+            }
+        }
+    }
+    return log;
+}
+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 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;
 }
 //# sourceMappingURL=config.js.map

package/dist/connection/registry.d.ts

@@ -48,7 +48,7 @@ export type ConfigValue = string | number | boolean | ValueRef | JsonConfigValue
 /**
  * Type guard for ValueRef.
  */
-export declare function isValueRef(value: ConfigValue): value is 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.

package/dist/connection/registry.js

@@ -22,7 +22,8 @@ function isValueRef(value) {
         value !== null &&
         !Array.isArray(value) &&
         Object.keys(value).length === 1 &&
-        'env' in value);
+        'env' in value &&
+        typeof value.env === 'string');
 }
 /**
  * Resolve a ValueRef to a string by looking up the environment variable.

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.365";
+export declare const MALLOY_VERSION = "0.0.366";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.365';
+exports.MALLOY_VERSION = '0.0.366';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.365",
+  "version": "0.0.366",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -47,9 +47,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.365",
-    "@malloydata/malloy-interfaces": "0.0.365",
-    "@malloydata/malloy-tag": "0.0.365",
+    "@malloydata/malloy-filter": "0.0.366",
+    "@malloydata/malloy-interfaces": "0.0.366",
+    "@malloydata/malloy-tag": "0.0.366",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",