@malloydata/malloy 0.0.374 → 0.0.376

package/dist/api/foundation/config_resolve.js

@@ -4,227 +4,113 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveConfig = resolveConfig;
+exports.prepareConfig = prepareConfig;
 const registry_1 = require("../../connection/registry");
 /**
- * Walk a compiled tree against the overlay dict and produce a plain
- * resolved POJO.
+ * Synchronous top-level walk of a compiled config tree. Extracts the
+ * non-connection sections (which only contain literals — see the section
+ * compilers) and hands back the compiled connection subtrees untouched.
  *
- * Two distinct "defaults" mechanisms, deliberately separated:
+ * Reference resolution for connection properties is *not* done here. It is
+ * deferred until `lookupConnection` is called, at which point the async
+ * walker in `config_lookup.ts` can `await` overlays that do IO (secret
+ * stores, session fetches, etc.). This keeps `MalloyConfig` construction
+ * synchronous and zero-IO.
  *
- *   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)
+ * Fabrication of bare `{is: typeName}` compiled entries for registered
+ * backends not otherwise represented happens here when the config opts in
+ * via `includeDefaultConnections`. Property defaults are filled in at
+ * lookup time alongside reference resolution.
  */
-function resolveConfig(compiled, overlays, log) {
-    const resolved = { connections: {} };
+function prepareConfig(compiled, _log) {
+    let compiledConnections = {};
+    let manifestPath;
+    let virtualMap;
     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);
+                compiledConnections = extractCompiledConnections(node);
                 break;
             }
             case 'manifestPath': {
-                const v = resolveNode(node, overlays, log);
-                if (typeof v === 'string')
-                    resolved.manifestPath = v;
+                if (node.kind === 'value' && typeof node.value === 'string') {
+                    manifestPath = node.value;
+                }
                 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);
+                // virtualMap is a literal dict slot — compileVirtualMap never
+                // produces a reference node. MalloyConfig converts the raw POJO
+                // into its runtime Map-of-Maps representation.
+                if (node.kind === 'value')
+                    virtualMap = node.value;
                 break;
             }
             case 'includeDefaultConnections': {
-                const v = resolveNode(node, overlays, log);
-                if (typeof v === 'boolean')
-                    includeDefaultConnections = v;
+                if (node.kind === 'value' && typeof node.value === 'boolean') {
+                    includeDefaultConnections = node.value;
+                }
                 break;
             }
         }
     }
     if (includeDefaultConnections) {
-        fabricateMissingConnections(resolved.connections);
+        fabricateMissingConnections(compiledConnections);
     }
-    // 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;
+    return { compiledConnections, manifestPath, virtualMap };
 }
-// =============================================================================
-// 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.
+ * Pull each well-formed compiled connection entry out of the `connections`
+ * subtree. Entries are already validated by `compileConnections` — anything
+ * shaped wrong was dropped or reported during compile. We defensively skip
+ * non-dict children here anyway.
  */
-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;
+function extractCompiledConnections(node) {
+    const out = {};
+    for (const [name, child] of Object.entries(node.entries)) {
+        if (child.kind === 'dict')
+            out[name] = child;
     }
-    return result;
+    return out;
 }
-// =============================================================================
-// 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.
+ * Add a bare `{is: typeName}` compiled entry for each registered connection
+ * type not already represented in `compiledConnections`. Only runs when the
+ * POJO sets `includeDefaultConnections: true`. Property values (including
+ * reference-shaped defaults like DuckDB's `{config: 'rootDirectory'}`) are
+ * *not* filled in here — that is the job of the async lookup resolver.
  *
- * A user-named connection that happens to share the type name but points
- * at a different backend is left alone.
+ * Skip rules:
+ *   - Type already in use: some existing entry has `is: typeName`.
+ *   - Name already taken: some existing entry is *named* `typeName`, even
+ *     if its `is` points elsewhere. This protects a user who writes
+ *     `{duckdb: {is: 'postgres', ...}}` — naming an entry after a type but
+ *     pointing at a different backend — from being clobbered.
  *
- * Mutates `connections` in place. Called only by `resolveConfig` on its
- * own freshly-built object.
+ * Mutates `compiledConnections` in place.
  */
-function fabricateMissingConnections(connections) {
+function fabricateMissingConnections(compiledConnections) {
     const presentTypes = new Set();
-    for (const entry of Object.values(connections)) {
-        if (typeof entry.is === 'string')
-            presentTypes.add(entry.is);
+    for (const entry of Object.values(compiledConnections)) {
+        const isNode = entry.entries['is'];
+        if ((isNode === null || isNode === void 0 ? void 0 : isNode.kind) === 'value' && typeof isNode.value === 'string') {
+            presentTypes.add(isNode.value);
+        }
     }
     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])
+        if (compiledConnections[typeName])
             continue;
-        connections[typeName] = { is: typeName };
+        compiledConnections[typeName] = {
+            kind: 'dict',
+            entries: {
+                is: { kind: 'value', value: 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/connection/registry.d.ts

@@ -87,6 +87,12 @@ export declare function getConnectionTypeDisplayName(typeName: string): string |
  * Get the names of all registered connection types.
  */
 export declare function getRegisteredConnectionTypes(): string[];
+/**
+ * Get the full definition (factory + properties + displayName) for a
+ * registered connection type. Used by the foundation layer's connection
+ * lookup to hand fully-resolved configs to the right factory.
+ */
+export declare function getConnectionTypeDef(typeName: string): ConnectionTypeDef | undefined;
 /**
  * Parse a JSON config string into a ConnectionsConfig.
  * Entries without a valid `is` field are silently dropped.

package/dist/connection/registry.js

@@ -9,6 +9,7 @@ exports.registerConnectionType = registerConnectionType;
 exports.getConnectionProperties = getConnectionProperties;
 exports.getConnectionTypeDisplayName = getConnectionTypeDisplayName;
 exports.getRegisteredConnectionTypes = getRegisteredConnectionTypes;
+exports.getConnectionTypeDef = getConnectionTypeDef;
 exports.readConnectionsConfig = readConnectionsConfig;
 exports.writeConnectionsConfig = writeConnectionsConfig;
 exports.createConnectionsFromConfig = createConnectionsFromConfig;
@@ -57,6 +58,14 @@ function getConnectionTypeDisplayName(typeName) {
 function getRegisteredConnectionTypes() {
     return [...registry.keys()];
 }
+/**
+ * Get the full definition (factory + properties + displayName) for a
+ * registered connection type. Used by the foundation layer's connection
+ * lookup to hand fully-resolved configs to the right factory.
+ */
+function getConnectionTypeDef(typeName) {
+    return registry.get(typeName);
+}
 /**
  * Parse a JSON config string into a ConnectionsConfig.
  * Entries without a valid `is` field are silently dropped.

package/dist/dialect/duckdb/duckdb.js

@@ -420,22 +420,18 @@ class DuckDBTypeParser extends tiny_parser_1.TinyParser {
         return token.text.toUpperCase();
     }
     typeDef() {
-        const wantID = this.next('id');
+        var _a, _b;
+        const wantID = this.expect('id');
         const id = this.sqlID(wantID);
         let baseType;
         if (id === 'VARCHAR') {
-            if (this.peek().type === 'size') {
-                this.next();
-            }
+            this.match('size');
         }
-        if ((id === 'DECIMAL' || id === 'NUMERIC') &&
-            this.peek().type === 'precision') {
-            this.next();
+        if ((id === 'DECIMAL' || id === 'NUMERIC') && this.match('precision')) {
             baseType = { type: 'number', numberType: 'float' };
         }
         else if (id === 'TIMESTAMP') {
-            if (this.peek().text.toUpperCase() === 'WITH') {
-                this.nextText('WITH', 'TIME', 'ZONE');
+            if (this.matchText('WITH', 'TIME', 'ZONE')) {
                 baseType = { type: 'timestamptz' };
             }
             else {
@@ -446,24 +442,21 @@ class DuckDBTypeParser extends tiny_parser_1.TinyParser {
             baseType = duckDBToMalloyTypes[id];
         }
         else if (id === 'STRUCT') {
-            this.next('(');
+            this.expect('(');
             baseType = { type: 'record', fields: [] };
             for (;;) {
-                const fieldName = this.next();
-                if (fieldName.type === 'qsingle' ||
-                    fieldName.type === 'qdouble' ||
-                    fieldName.type === 'id') {
-                    const fieldType = this.typeDef();
-                    baseType.fields.push((0, malloy_types_1.mkFieldDef)(fieldType, this.unquoteName(fieldName)));
-                }
-                else {
-                    if (fieldName.type !== ')') {
+                const fieldName = (_b = (_a = this.match('qsingle')) !== null && _a !== void 0 ? _a : this.match('qdouble')) !== null && _b !== void 0 ? _b : this.match('id');
+                if (!fieldName) {
+                    if (!this.match(')')) {
                         throw this.parseError('Expected identifier or ) to end STRUCT');
                     }
                     break;
                 }
-                if (this.peek().type === ',') {
-                    this.next();
+                const fieldType = this.typeDef();
+                baseType.fields.push((0, malloy_types_1.mkFieldDef)(fieldType, this.unquoteName(fieldName)));
+                if (!this.match(',')) {
+                    this.expect(')');
+                    break;
                 }
             }
         }
@@ -472,10 +465,8 @@ class DuckDBTypeParser extends tiny_parser_1.TinyParser {
                 // unknown field type, strip all type decorations, there was a regex for this
                 // in the pre-parser code, but no tests, so this is also untested
                 let idEnd = wantID.cursor + wantID.text.length;
-                if (this.peek().type === 'precision') {
-                    this.next();
-                }
-                if (this.peek().type === 'eof') {
+                this.match('precision');
+                if (this.eof()) {
                     idEnd = this.input.length;
                 }
                 baseType = {
@@ -487,8 +478,7 @@ class DuckDBTypeParser extends tiny_parser_1.TinyParser {
                 throw this.parseError('Could not understand type');
             }
         }
-        while (this.peek().type === 'arrayOf') {
-            this.next();
+        while (this.match('arrayOf')) {
             if (baseType.type === 'record') {
                 baseType = {
                     type: 'array',

package/dist/dialect/tiny_parser.d.ts

@@ -4,9 +4,41 @@ export interface TinyToken {
     text: string;
 }
 /**
- * Simple framework for writing schema parsers. The parsers using this felt
- * better than the more ad-hoc code they replaced, and are smaller than
- * using a parser generator.
+ * Tiny combined lexer/parser for short recursive-descent parsers.
+ *
+ * TinyParser is intentionally small and biased toward readability over
+ * framework features. It is primarily used for schema and type parsers where
+ * a hand-written parser is clearer than ad-hoc regex matching, but a parser
+ * generator would be overkill.
+ *
+ * Design goals:
+ * - Keep parser implementations short and readable.
+ * - Support custom tokenization rules per parser.
+ * - Make parser intent obvious at call sites.
+ * - Minimize hidden consumption and parser-state surprises.
+ *
+ * Core parser API:
+ * - peek(): inspect the next token without consuming it.
+ * - read(): consume and return the next token, regardless of type.
+ * - eof(): true if the next token is end-of-input.
+ * - expect(...types): consume a required sequence of token types.
+ * - expectText(...texts): consume a required sequence of token texts.
+ * - match(...types): consume an optional sequence of token types.
+ * - matchText(...texts): consume an optional sequence of token texts.
+ *
+ * Semantics:
+ * - expect*() is for required grammar and throws on failure.
+ * - match*() is for optional grammar and is atomic. If the full sequence does
+ *   not match, nothing is consumed.
+ * - peek() remains available, but most optional syntax should prefer match*().
+ *
+ * Token rules are tested in order. The first matching rule wins.
+ *
+ * Special token rule names:
+ * - space: matched text is skipped and never returned.
+ * - char: matched text becomes both token.type and token.text.
+ * - q*: any token name starting with q is treated as quoted text and has its
+ *   first and last characters stripped from token.text.
  *
  * NOTE: All parse errors are exceptions.
  */
@@ -14,33 +46,36 @@ export declare class TinyParseError extends Error {
 }
 export declare class TinyParser {
     readonly input: string;
-    private tokens;
+    private readonly tokens;
+    private tokenCursor;
+    private scanCursor;
+    private scanState;
     protected parseCursor: number;
-    private lookAhead?;
-    private tokenMap;
+    private readonly tokenMap;
     /**
-     * The token map is tested in order. Return TinyToken
-     * is {type: tokenMapKey, text: matchingText }, except
-     * for the special tokenMapKeys:
-     * * space: skipped and never returned
-     * * char: matched string return in both .type and .text
-     * * q*: any token name starting with 'q' is assumed to be
-     *   a quoted string and the text will have the first and
-     *   last characters stripped
+     * The token map is tested in order and the first matching rule wins.
      */
     constructor(input: string, tokenMap?: Record<string, RegExp>);
     parseError(str: string): TinyParseError;
     peek(): TinyToken;
-    private getNext;
+    read(): TinyToken;
+    eof(): boolean;
+    private peekAt;
     /**
      * Return next token, if any token types are passed, read and require those
      * tokens, then return the last one.
      * @param types list of token types
      * @returns The last token read
      */
-    next(...types: string[]): TinyToken;
-    nextText(...texts: string[]): TinyToken;
+    expect(...types: string[]): TinyToken;
+    expectText(...texts: string[]): TinyToken;
+    match(...types: string[]): TinyToken | undefined;
+    matchText(...texts: string[]): TinyToken | undefined;
     skipTo(type: string): void;
     dump(): TinyToken[];
-    private tokenize;
+    private fillBufferTo;
+    private consume;
+    private readNextToken;
+    private scanToken;
+    private eofToken;
 }