@malloydata/malloy 0.0.365 → 0.0.367

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/lang/ast/statements/define-source.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefineSourceList = exports.DefineSource = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const source_def_utils_1 = require("../../../model/source_def_utils");
+const persist_utils_1 = require("../../../model/persist_utils");
 const error_factory_1 = require("../error-factory");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
@@ -67,14 +68,15 @@ class DefineSource extends malloy_element_1.MalloyElement {
             as: this.name,
             location: this.location,
         };
-        if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
-            entry.sourceID = (0, source_def_utils_1.mkSourceID)(this.name, (_b = this.location) === null || _b === void 0 ? void 0 : _b.url);
-        }
         if (this.note) {
             entry.annotation = structDef.annotation
                 ? { ...this.note, inherits: structDef.annotation }
                 : this.note;
         }
+        if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
+            entry.sourceID = (0, source_def_utils_1.mkSourceID)(this.name, (_b = this.location) === null || _b === void 0 ? void 0 : _b.url);
+            entry.persistent = (0, persist_utils_1.checkPersistAnnotation)(entry).persist;
+        }
         entry.partitionComposite =
             (_d = (0, composite_source_utils_1.getPartitionCompositeDesc)(this.note, structDef, (_c = this.sourceExpr) !== null && _c !== void 0 ? _c : this)) !== null && _d !== void 0 ? _d : structDef.partitionComposite;
         doc.setEntry(this.name, { entry, exported: this.exported });

package/dist/model/malloy_types.d.ts

@@ -767,6 +767,7 @@ export declare function isSourceRegistryReference(entry: SourceRegistryEntry): e
 export interface PersistableSourceProperties {
     sourceID?: SourceID;
     extends?: SourceID;
+    persistent?: boolean;
 }
 export interface SQLSourceDef extends SourceDefBase, PersistableSourceProperties {
     type: 'sql_select';

package/dist/model/persist_utils.d.ts

@@ -1,6 +1,14 @@
 import type { ModelDef, SourceDef, Query } from './malloy_types';
 import type { LogMessage } from '../lang';
 import type { BuildNode } from '../api/foundation/types';
+/**
+ * Check if a source has the #@ persist annotation.
+ * Returns both the persist flag and any tag parse errors.
+ */
+export declare function checkPersistAnnotation(source: SourceDef): {
+    persist: boolean;
+    log: LogMessage[];
+};
 /**
  * Find persistent dependencies for a source or query, returning a nested DAG.
  *

package/dist/model/persist_utils.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPersistAnnotation = checkPersistAnnotation;
 exports.findPersistentDependencies = findPersistentDependencies;
 exports.minimalBuildGraph = minimalBuildGraph;
 const malloy_types_1 = require("./malloy_types");

package/dist/model/query_query.js

@@ -542,8 +542,8 @@ class QueryQuery extends query_node_1.QueryField {
                 return qs.structDef.pipeSQL;
             case 'query_source': {
                 const { buildManifest, connectionDigests } = (_d = qs.prepareResultOptions) !== null && _d !== void 0 ? _d : {};
-                // Check manifest for this source
-                if (buildManifest && connectionDigests) {
+                // Check manifest for this source (only if it was marked persistent at definition time)
+                if (buildManifest && connectionDigests && qs.structDef.persistent) {
                     const connDigest = (0, malloy_types_1.safeRecordGet)(connectionDigests, qs.structDef.connection);
                     if (connDigest) {
                         // Compile with empty opts to get manifest-ignorant SQL for BuildID

package/dist/model/source_def_utils.js

@@ -59,6 +59,7 @@ function mkQuerySourceDef(base, query, name) {
         // PersistableSourceProperties - explicitly NOT copied
         // sourceID: undefined,
         // extends: undefined,
+        // persistent: undefined,
     };
 }
 /**
@@ -97,6 +98,7 @@ function mkSQLSourceDef(base, selectStr, selectSegments) {
         // PersistableSourceProperties - explicitly NOT copied
         // sourceID: undefined,
         // extends: undefined,
+        // persistent: undefined,
     };
 }
 /**

package/dist/model/sql_compiled.js

@@ -52,8 +52,8 @@ function expandSegment(segment, opts, quoteTablePath, compileQuery) {
  */
 function expandPersistableSource(source, opts, quoteTablePath, compileQuery) {
     const { buildManifest, connectionDigests } = opts;
-    // Try manifest lookup if we have the required info
-    if (buildManifest && connectionDigests) {
+    // Try manifest lookup if we have the required info (only for persistent sources)
+    if (buildManifest && connectionDigests && source.persistent) {
         const connDigest = (0, malloy_types_1.safeRecordGet)(connectionDigests, source.connection);
         if (connDigest) {
             // Get the SQL for this source to compute BuildID (no opts = full SQL)

package/dist/version.d.ts

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

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.367';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.365",
+  "version": "0.0.367",
   "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.367",
+    "@malloydata/malloy-interfaces": "0.0.367",
+    "@malloydata/malloy-tag": "0.0.367",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",