@malloydata/malloy 0.0.362 → 0.0.364

package/dist/api/core.js

@@ -167,7 +167,8 @@ function getSchemaFields(schema) {
     return fields;
 }
 function compilerNeedsToUpdate(compilerNeeds) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _l;
     const update = {
         urls: {},
         tables: {},
@@ -200,10 +201,22 @@ function compilerNeedsToUpdate(compilerNeeds) {
                 update.translations[translation.url] = modelDef;
             }
         }
+        for (const connection of (_g = compilerNeeds.connections) !== null && _g !== void 0 ? _g : []) {
+            if (connection.dialect) {
+                (_h = update.connectionDialects) !== null && _h !== void 0 ? _h : (update.connectionDialects = {});
+                update.connectionDialects[connection.name] = connection.dialect;
+            }
+            else {
+                (_j = update.errors) !== null && _j !== void 0 ? _j : (update.errors = {});
+                (_k = (_l = update.errors).connectionDialects) !== null && _k !== void 0 ? _k : (_l.connectionDialects = {});
+                update.errors.connectionDialects[connection.name] =
+                    `Connection '${connection.name}' not found`;
+            }
+        }
     }
     return update;
 }
-function convertCompilerNeeds(compileSQL, urls, tables) {
+function convertCompilerNeeds(compileSQL, urls, tables, connectionDialects) {
     var _a, _b, _c;
     const compilerNeeds = {};
     const neededConnections = new Set();
@@ -235,6 +248,11 @@ function convertCompilerNeeds(compileSQL, urls, tables) {
             neededConnections.add(connectionName);
         }
     }
+    if (connectionDialects !== undefined) {
+        for (const connName in connectionDialects) {
+            neededConnections.add(connectionDialects[connName].connectionName);
+        }
+    }
     if (neededConnections.size > 0) {
         compilerNeeds.connections = Array.from(neededConnections).map(c => ({
             name: c,
@@ -350,7 +368,7 @@ function _statedCompileModel(state) {
         }
     }
     else {
-        const compilerNeeds = convertCompilerNeeds(result.compileSQL, result.urls, result.tables);
+        const compilerNeeds = convertCompilerNeeds(result.compileSQL, result.urls, result.tables, result.connectionDialects);
         const timingInfo = timer.stop();
         return { compilerNeeds, logs: result.problems, timingInfo };
     }

package/dist/api/foundation/compile.js

@@ -273,6 +273,26 @@ class Malloy {
                         }
                     }
                 }
+                if (result.connectionDialects) {
+                    for (const connName in result.connectionDialects) {
+                        const { connectionName } = result.connectionDialects[connName];
+                        try {
+                            const connection = await connections.lookupConnection(connectionName);
+                            translator.update({
+                                connectionDialects: { [connName]: connection.dialectName },
+                            });
+                        }
+                        catch (error) {
+                            translator.update({
+                                errors: {
+                                    connectionDialects: {
+                                        [connName]: error.toString(),
+                                    },
+                                },
+                            });
+                        }
+                    }
+                }
                 if (result.compileSQL) {
                     // Unlike other requests, these do not come in batches
                     const toCompile = result.compileSQL;

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

@@ -1,6 +1,6 @@
 import type { Connection, LookupConnection } from '../../connection/types';
 import type { URLReader, EventStream } from '../../runtime_types';
-import type { ModelDef, Query as InternalQuery, SearchIndexResult, SearchValueMapResult, QueryRunStats, BuildManifest } from '../../model';
+import type { ModelDef, Query as InternalQuery, SearchIndexResult, SearchValueMapResult, QueryRunStats, BuildManifest, VirtualMap } from '../../model';
 import type { Dialect } from '../../dialect';
 import type { RunSQLOptions } from '../../run_sql_options';
 import type { CacheManager } from './cache';
@@ -40,11 +40,13 @@ export declare class Runtime {
     private _eventStream;
     private _cacheManager;
     private _buildManifest;
-    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, }: {
+    private _virtualMap;
+    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, virtualMap, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
         buildManifest?: BuildManifest;
+        virtualMap?: VirtualMap;
     } & Connectionable);
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -70,6 +72,14 @@ export declare class Runtime {
      */
     get buildManifest(): BuildManifest | undefined;
     set buildManifest(manifest: BuildManifest | undefined);
+    /**
+     * The virtual map for virtual source resolution.
+     * When set, compiled queries automatically resolve virtual sources
+     * against this map. Can be overridden per-query via
+     * CompileQueryOptions.virtualMap.
+     */
+    get virtualMap(): VirtualMap | undefined;
+    set virtualMap(map: VirtualMap | undefined);
     /**
      * Load a Malloy model by URL or contents.
      *
@@ -142,19 +152,21 @@ export declare class Runtime {
 }
 export declare class ConnectionRuntime extends Runtime {
     readonly rawConnections: Connection[];
-    constructor({ urlReader, connections, buildManifest, }: {
+    constructor({ urlReader, connections, buildManifest, virtualMap, }: {
         urlReader?: URLReader;
         connections: Connection[];
         buildManifest?: BuildManifest;
+        virtualMap?: VirtualMap;
     });
 }
 export declare class SingleConnectionRuntime<T extends Connection = Connection> extends Runtime {
     readonly connection: T;
-    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, }: {
+    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, virtualMap, }: {
         urlReader?: URLReader;
         eventStream?: EventStream;
         cacheManager?: CacheManager;
         buildManifest?: BuildManifest;
+        virtualMap?: VirtualMap;
         connection: T;
     });
     get supportsNesting(): boolean;

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, eventStream, cacheManager, buildManifest, }) {
+    constructor({ urlReader, connections, connection, eventStream, cacheManager, buildManifest, virtualMap, }) {
         this.isTestRuntime = false;
         if (connections === undefined) {
             if (connection === undefined) {
@@ -64,6 +64,7 @@ class Runtime {
         this._eventStream = eventStream;
         this._cacheManager = cacheManager;
         this._buildManifest = buildManifest;
+        this._virtualMap = virtualMap;
     }
     /**
      * @return The `CacheManager` for this runtime instance.
@@ -101,6 +102,18 @@ class Runtime {
     set buildManifest(manifest) {
         this._buildManifest = manifest;
     }
+    /**
+     * The virtual map for virtual source resolution.
+     * When set, compiled queries automatically resolve virtual sources
+     * against this map. Can be overridden per-query via
+     * CompileQueryOptions.virtualMap.
+     */
+    get virtualMap() {
+        return this._virtualMap;
+    }
+    set virtualMap(map) {
+        this._virtualMap = map;
+    }
     /**
      * Load a Malloy model by URL or contents.
      *
@@ -223,23 +236,25 @@ exports.Runtime = Runtime;
 // ConnectionRuntime and SingleConnectionRuntime
 // =============================================================================
 class ConnectionRuntime extends Runtime {
-    constructor({ urlReader, connections, buildManifest, }) {
+    constructor({ urlReader, connections, buildManifest, virtualMap, }) {
         super({
             connections: readers_1.FixedConnectionMap.fromArray(connections),
             urlReader,
             buildManifest,
+            virtualMap,
         });
         this.rawConnections = connections;
     }
 }
 exports.ConnectionRuntime = ConnectionRuntime;
 class SingleConnectionRuntime extends Runtime {
-    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, }) {
+    constructor({ urlReader, connection, eventStream, cacheManager, buildManifest, virtualMap, }) {
         super({
             urlReader,
             eventStream,
             cacheManager,
             buildManifest,
+            virtualMap,
             connection,
         });
         this.connection = connection;
@@ -569,7 +584,7 @@ class QueryMaterializer extends FluentState {
      */
     loadPreparedResult(options) {
         return this.makePreparedResultMaterializer(async () => {
-            var _a;
+            var _a, _b;
             const preparedQuery = await this.materialize();
             const mergedOptions = {
                 eventStream: this.eventStream,
@@ -610,11 +625,14 @@ class QueryMaterializer extends FluentState {
                     connectionDigests[connName] = conn.getDigest();
                 }
             }
+            // Use virtualMap from options if provided, otherwise fall back to Runtime's.
+            const virtualMap = (_b = mergedOptions.virtualMap) !== null && _b !== void 0 ? _b : this.runtime.virtualMap;
             // Build PrepareResultOptions from CompileQueryOptions + connectionDigests
             const prepareResultOptions = {
                 defaultRowLimit: mergedOptions.defaultRowLimit,
                 buildManifest,
                 connectionDigests,
+                virtualMap,
             };
             return preparedQuery.getPreparedResult({
                 ...mergedOptions,

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

@@ -1,5 +1,5 @@
 import type { EventStream } from '../../runtime_types';
-import type { BuildManifest } from '../../model';
+import type { BuildManifest, VirtualMap } from '../../model';
 /**
  * An empty BuildManifest with no entries and strict mode off.
  * Use this to explicitly suppress manifest substitution in a query:
@@ -33,6 +33,8 @@ export interface CompileQueryOptions {
     buildManifest?: BuildManifest;
     /** Map from connectionName to connectionDigest (from Connection.getDigest()) */
     connectionDigests?: Record<string, string>;
+    /** Map from connectionName → virtualName → tablePath for virtual source resolution */
+    virtualMap?: VirtualMap;
 }
 /**
  * A node in the build graph (recursive DAG structure).

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, DatabricksDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, TinyParser, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, TinyToken, } from './dialect';
-export type { QueryRecord, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildID, BuildManifest, BuildManifestEntry, } from './model';
+export type { QueryRecord, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildID, BuildManifest, BuildManifestEntry, VirtualMap, } from './model';
 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';

package/dist/lang/ast/index.d.ts

@@ -1,5 +1,6 @@
 export * from './query-properties/nest';
 export * from './statements/define-source';
+export * from './statements/define-user-type';
 export * from './statements/define-query';
 export * from './source-elements/source';
 export * from './source-elements/refined-source';
@@ -9,6 +10,7 @@ export * from './source-query-elements/sq-refine';
 export * from './source-query-elements/sq-source';
 export * from './source-query-elements/sq-reference';
 export * from './source-query-elements/sq-extend';
+export * from './source-query-elements/sq-typed-source';
 export * from './source-query-elements/sq-compose';
 export * from './source-query-elements/include-item';
 export * from './source-properties/field-list-edit';
@@ -16,6 +18,7 @@ export * from './source-properties/primary-key';
 export * from './source-properties/renames';
 export * from './source-properties/views';
 export * from './source-properties/timezone-statement';
+export * from './source-properties/user-type-shape';
 export * from './expressions/apply';
 export * from './expressions/binary-numeric';
 export * from './expressions/boolean';
@@ -100,6 +103,8 @@ export * from './source-elements/named-source';
 export * from './source-elements/query-source';
 export * from './source-elements/sql-source';
 export * from './source-elements/table-source';
+export * from './source-elements/typed-source';
+export * from './source-elements/virtual-source';
 export * from './sql-elements/sql-string';
 export * from './types/annotation-elements';
 export * from './types/binary_operators';

package/dist/lang/ast/index.js

@@ -38,6 +38,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./query-properties/nest"), exports);
 __exportStar(require("./statements/define-source"), exports);
+__exportStar(require("./statements/define-user-type"), exports);
 __exportStar(require("./statements/define-query"), exports);
 __exportStar(require("./source-elements/source"), exports);
 __exportStar(require("./source-elements/refined-source"), exports);
@@ -47,6 +48,7 @@ __exportStar(require("./source-query-elements/sq-refine"), exports);
 __exportStar(require("./source-query-elements/sq-source"), exports);
 __exportStar(require("./source-query-elements/sq-reference"), exports);
 __exportStar(require("./source-query-elements/sq-extend"), exports);
+__exportStar(require("./source-query-elements/sq-typed-source"), exports);
 __exportStar(require("./source-query-elements/sq-compose"), exports);
 __exportStar(require("./source-query-elements/include-item"), exports);
 __exportStar(require("./source-properties/field-list-edit"), exports);
@@ -54,6 +56,7 @@ __exportStar(require("./source-properties/primary-key"), exports);
 __exportStar(require("./source-properties/renames"), exports);
 __exportStar(require("./source-properties/views"), exports);
 __exportStar(require("./source-properties/timezone-statement"), exports);
+__exportStar(require("./source-properties/user-type-shape"), exports);
 __exportStar(require("./expressions/apply"), exports);
 __exportStar(require("./expressions/binary-numeric"), exports);
 __exportStar(require("./expressions/boolean"), exports);
@@ -138,6 +141,8 @@ __exportStar(require("./source-elements/named-source"), exports);
 __exportStar(require("./source-elements/query-source"), exports);
 __exportStar(require("./source-elements/sql-source"), exports);
 __exportStar(require("./source-elements/table-source"), exports);
+__exportStar(require("./source-elements/typed-source"), exports);
+__exportStar(require("./source-elements/virtual-source"), exports);
 __exportStar(require("./sql-elements/sql-string"), exports);
 __exportStar(require("./types/annotation-elements"), exports);
 __exportStar(require("./types/binary_operators"), exports);

package/dist/lang/ast/source-elements/named-source.js

@@ -99,6 +99,10 @@ class NamedSource extends source_1.Source {
             this.logError('invalid-source-from-connection', `Cannot construct a source from a connection '${this.refName}'`);
             return;
         }
+        else if (entry.type === 'userType') {
+            this.logError('invalid-source-from-user-type', `Cannot construct a source from a user type '${this.refName}'`);
+            return;
+        }
         else {
             (_a = this.document()) === null || _a === void 0 ? void 0 : _a.checkExperimentalDialect(this, entry.dialect);
             if ((0, malloy_types_1.isSourceDef)(entry)) {

package/dist/lang/ast/source-elements/typed-source.d.ts

@@ -0,0 +1,23 @@
+import type { NonDefaultAccessModifierLabel, SourceDef } from '../../../model/malloy_types';
+import { Source } from './source';
+import type { ParameterSpace } from '../field-space/parameter-space';
+import type { ModelEntryReference } from '../types/malloy-element';
+export declare const USER_TYPE_HIDDEN_ACCESS: NonDefaultAccessModifierLabel;
+/**
+ * A Source wrapped with user type constraints via the `::` operator.
+ * Resolves and merges user types (validating no conflicts), then:
+ * - virtual sources: user-type fields not in the source are added
+ * - all other sources: user-type fields not in the source are an error
+ * - in both cases: source fields not in any user type are marked
+ *   with USER_TYPE_HIDDEN_ACCESS
+ *
+ * e.g. `source::MyType` or `source::(A, B)`
+ */
+export declare class TypedSource extends Source {
+    readonly innerSource: Source;
+    readonly userTypes: ModelEntryReference[];
+    elementType: string;
+    constructor(innerSource: Source, userTypes: ModelEntryReference[]);
+    getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
+    private nextShape;
+}

package/dist/lang/ast/source-elements/typed-source.js

@@ -0,0 +1,133 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedSource = exports.USER_TYPE_HIDDEN_ACCESS = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const source_1 = require("./source");
+exports.USER_TYPE_HIDDEN_ACCESS = 'internal';
+/**
+ * With each field, keep the shape reference it came from, for error reporting
+ */
+class Shape extends Map {
+}
+/**
+ * A Source wrapped with user type constraints via the `::` operator.
+ * Resolves and merges user types (validating no conflicts), then:
+ * - virtual sources: user-type fields not in the source are added
+ * - all other sources: user-type fields not in the source are an error
+ * - in both cases: source fields not in any user type are marked
+ *   with USER_TYPE_HIDDEN_ACCESS
+ *
+ * e.g. `source::MyType` or `source::(A, B)`
+ */
+class TypedSource extends source_1.Source {
+    constructor(innerSource, userTypes) {
+        super({ innerSource });
+        this.innerSource = innerSource;
+        this.userTypes = userTypes;
+        this.elementType = 'typedSource';
+        this.has({ userTypes });
+    }
+    getSourceDef(parameterSpace) {
+        const sourceDef = this.innerSource.getSourceDef(parameterSpace);
+        // Merge user types, while validating no field conflicts
+        const [outputShape, ...remainingShapes] = this.nextShape();
+        if (outputShape === undefined) {
+            return sourceDef;
+        }
+        for (const mergeShape of remainingShapes) {
+            for (const [name, { field, fromShape }] of mergeShape) {
+                const existing = outputShape.get(name);
+                if (existing && !malloy_types_1.TD.eq(field, existing.field)) {
+                    fromShape.logError('user-type-field-conflict', `Field '${name}' has conflicting types in user types '${existing.fromShape.name}' and '${fromShape.name}'`);
+                }
+                else {
+                    outputShape.set(name, { field, fromShape });
+                }
+            }
+        }
+        const isVirtual = sourceDef.type === 'virtual';
+        const sourceFields = new Map(sourceDef.fields.map(f => { var _a; return [(_a = f.as) !== null && _a !== void 0 ? _a : f.name, f]; }));
+        const fieldsToAdd = [];
+        // Validate/Enforce that this source matches the shape
+        for (const [name, { field, fromShape }] of outputShape) {
+            const sourceField = sourceFields.get(name);
+            if (sourceField === undefined) {
+                if (isVirtual) {
+                    fieldsToAdd.push(field);
+                }
+                else {
+                    fromShape.logError('user-type-field-missing', `Source is missing field '${field.name}' required by user type '${fromShape.name}'`);
+                }
+            }
+            else if (!isVirtual &&
+                (0, malloy_types_1.fieldIsIntrinsic)(sourceField) &&
+                !malloy_types_1.TD.eq(field, sourceField)) {
+                fromShape.logError('user-type-type-mismatch', `Type mismatch for '${name}': user type '${fromShape.name}' declares ${field.type} but source has ${sourceField.type}`);
+            }
+        }
+        // Intrinsic fields not in any shape: mark as hidden.
+        // Matching fields inherit annotations from the shape.
+        const resultFields = sourceDef.fields.map(f => {
+            var _a;
+            const name = (_a = f.as) !== null && _a !== void 0 ? _a : f.name;
+            const shapeEntry = outputShape.get(name);
+            if (!shapeEntry || !(0, malloy_types_1.fieldIsIntrinsic)(f)) {
+                return (0, malloy_types_1.fieldIsIntrinsic)(f) && !shapeEntry
+                    ? { ...f, accessModifier: exports.USER_TYPE_HIDDEN_ACCESS }
+                    : f;
+            }
+            const shapeAnnotation = shapeEntry.field.annotation;
+            if (!shapeAnnotation) {
+                return f;
+            }
+            return { ...f, annotation: mergeAnnotation(f.annotation, shapeAnnotation) };
+        });
+        return {
+            ...sourceDef,
+            fields: [...resultFields, ...fieldsToAdd],
+        };
+    }
+    *nextShape() {
+        for (const ref of this.userTypes) {
+            const next = new Shape();
+            const entry = this.modelEntry(ref);
+            if (entry === undefined) {
+                ref.logError('user-type-not-found', `User type '${ref.name}' is not defined`);
+                continue;
+            }
+            if (!(0, malloy_types_1.isUserTypeDef)(entry.entry)) {
+                ref.logError('not-a-user-type', `'${ref.name}' is not a user type`);
+                continue;
+            }
+            for (const sf of entry.entry.fields) {
+                const field = (0, malloy_types_1.mkFieldDef)(sf.typeDef, sf.name);
+                if (sf.annotation) {
+                    field.annotation = sf.annotation;
+                }
+                next.set(sf.name, { field, fromShape: ref });
+            }
+            yield next;
+        }
+    }
+}
+exports.TypedSource = TypedSource;
+/**
+ * Insert shapeAnnotation behind fieldAnnotation in the inherits chain.
+ * Chain: field → shape → (whatever field previously inherited from)
+ */
+function mergeAnnotation(fieldAnnotation, shapeAnnotation) {
+    if (!fieldAnnotation) {
+        return shapeAnnotation;
+    }
+    return {
+        ...fieldAnnotation,
+        inherits: fieldAnnotation.inherits
+            ? { ...shapeAnnotation, inherits: fieldAnnotation.inherits }
+            : shapeAnnotation,
+    };
+}
+//# sourceMappingURL=typed-source.js.map

package/dist/lang/ast/source-elements/virtual-source.d.ts

@@ -0,0 +1,10 @@
+import type { SourceDef } from '../../../model/malloy_types';
+import { Source } from './source';
+import type { ModelEntryReference } from '../types/malloy-element';
+export declare class VirtualTableSource extends Source {
+    readonly connectionName: ModelEntryReference;
+    readonly virtualName: string;
+    elementType: string;
+    constructor(connectionName: ModelEntryReference, virtualName: string);
+    getSourceDef(): SourceDef;
+}

package/dist/lang/ast/source-elements/virtual-source.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualTableSource = void 0;
+const source_1 = require("./source");
+const error_factory_1 = require("../error-factory");
+class VirtualTableSource extends source_1.Source {
+    constructor(connectionName, virtualName) {
+        super();
+        this.connectionName = connectionName;
+        this.virtualName = virtualName;
+        this.elementType = 'virtualTableSource';
+        this.has({ connectionName });
+    }
+    getSourceDef() {
+        var _a, _b, _c;
+        const connection = this.modelEntry(this.connectionName);
+        const name = this.connectionName.refString;
+        if (connection === undefined) {
+            (_a = this.namespace()) === null || _a === void 0 ? void 0 : _a.setEntry(name, { entry: { type: 'connection', name }, exported: true }, true);
+        }
+        else if (connection.entry.type !== 'connection') {
+            this.connectionName.logError('invalid-connection-for-table-source', `${this.connectionName.refString} is not a connection`);
+            return error_factory_1.ErrorFactory.structDef;
+        }
+        const dialect = (_b = this.translator()) === null || _b === void 0 ? void 0 : _b.root.connectionDialectZone.get(name);
+        if (dialect === undefined) {
+            this.logError('virtual-source-unknown-dialect', `Cannot determine dialect for connection '${name}'`);
+            return error_factory_1.ErrorFactory.structDef;
+        }
+        const sourceDef = {
+            type: 'virtual',
+            name: this.virtualName,
+            dialect,
+            connection: name,
+            fields: [],
+            location: this.location,
+        };
+        (_c = this.document()) === null || _c === void 0 ? void 0 : _c.rememberToAddModelAnnotations(sourceDef);
+        return sourceDef;
+    }
+}
+exports.VirtualTableSource = VirtualTableSource;
+//# sourceMappingURL=virtual-source.js.map

package/dist/lang/ast/source-properties/user-type-shape.d.ts

@@ -0,0 +1,29 @@
+import type { Annotation, AtomicTypeDef, UserTypeFieldDef } from '../../../model/malloy_types';
+import { ListOf, MalloyElement } from '../types/malloy-element';
+import type { Noteable } from '../types/noteable';
+import { extendNoteMethod } from '../types/noteable';
+export declare abstract class UserTypeMember extends MalloyElement implements Noteable {
+    readonly name: string;
+    readonly isNoteableObj = true;
+    extendNote: typeof extendNoteMethod;
+    note?: Annotation;
+    constructor(name: string);
+    abstract userTypeFieldDef(): UserTypeFieldDef;
+}
+export declare class UserTypeMemberDef extends UserTypeMember {
+    readonly typeDef: AtomicTypeDef;
+    elementType: string;
+    constructor(name: string, typeDef: AtomicTypeDef);
+    userTypeFieldDef(): UserTypeFieldDef;
+}
+export declare class UserTypeMemberIndirect extends UserTypeMember {
+    readonly shapeName: string;
+    readonly arrayDepth: number;
+    elementType: string;
+    constructor(name: string, shapeName: string, arrayDepth?: number);
+    userTypeFieldDef(): UserTypeFieldDef;
+}
+export declare class UserTypeShape extends ListOf<UserTypeMember> {
+    elementType: string;
+    userTypeFieldDefs(): UserTypeFieldDef[];
+}