@minnowdb/core 0.5.0 → 0.6.1

package/dist/engine/query.js

@@ -6,10 +6,10 @@ import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, rende
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 import { stringArgument } from "./sql-semantics.js";
-import { jsonAtPath, jsonConstructor, jsonIsValid, jsonValueOf, parseJsonPath, } from "./sql-json.js";
+import { jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath } from "./sql-json.js";
 import { optimizePlan } from "./optimizer.js";
 import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
-import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
+import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery, } from "./vector.js";
 /** Domain metadata for an execution path that has no catalog-backed type information. */
 export function unknownColumnDomains(columns) {
@@ -264,7 +264,7 @@ export function scalarFunctionValue(name, values) {
     }
     if (name === "JSON_ARRAY" || name === "JSON_OBJECT") {
         // These build from every argument, so a NULL first one is data, not an early exit.
-        return jsonConstructor(name, values);
+        return preservedJsonDomainValue(jsonConstructor(name, values));
     }
     if (name === "ARRAY")
         return arrayDomainValue(values);
@@ -394,7 +394,7 @@ export function scalarFunctionValue(name, values) {
             if (!found.found || found.value === undefined)
                 return null;
             // JSON_QUERY returns JSON text, so a selected string keeps its quotes.
-            return JSON.stringify(found.value);
+            return preservedJsonDomainValue(JSON.stringify(found.value));
         }
         case "LPAD":
         case "RPAD": {
@@ -800,6 +800,7 @@ const aggregateNames = new Set([
     "MAX",
     "JSON_ARRAYAGG",
     "STRING_AGG",
+    "MINNOW_SINGLE_VALUE",
 ]);
 /** Set functions the parser builds from COUNT/SUM rather than from their own accumulator. */
 const statisticalAggregates = new Set([
@@ -1502,8 +1503,12 @@ export function containsParameter(expression) {
     return childExpressions(expression).some(containsParameter);
 }
 export function blockHasParameters(block) {
-    if (block.limitParameter !== undefined || block.offsetParameter !== undefined)
+    if (block.limitParameter !== undefined ||
+        block.offsetParameter !== undefined ||
+        (block.limitValidationParameters?.length ?? 0) > 0 ||
+        (block.offsetValidationParameters?.length ?? 0) > 0) {
         return true;
+    }
     const expressions = [];
     forEachBlockExpression(block, (expression) => expressions.push(expression));
     return (expressions.some(containsParameter) ||
@@ -1608,6 +1613,14 @@ function bindBlock(block, values) {
         block.offset = validateOffset(numeric(values[block.offsetParameter] ?? null));
         delete block.offsetParameter;
     }
+    for (const index of block.limitValidationParameters ?? []) {
+        validateLimit(numeric(values[index] ?? null));
+    }
+    for (const index of block.offsetValidationParameters ?? []) {
+        validateOffset(numeric(values[index] ?? null));
+    }
+    delete block.limitValidationParameters;
+    delete block.offsetValidationParameters;
     for (const item of block.select)
         item.expression = bindExpression(item.expression, values);
     for (const predicate of [...block.predicates, ...block.having]) {
@@ -1765,7 +1778,10 @@ export function bindStatementParameters(statement, params) {
  */
 export function inferBlockSchema(plan, schemas) {
     const sources = [plan.base, ...plan.joins];
-    const multipleSources = sources.length > 1;
+    const multipleSources = sources.filter((source) => {
+        const schema = schemas.get(source.table);
+        return schema === undefined || schema.some((column) => !column.name.startsWith("\0"));
+    }).length > 1;
     const wildcardSchema = (source) => (schemas.get(source.table) ?? [])
         .filter((column) => !column.name.startsWith("\0"))
         .map((column) => ({
@@ -1889,6 +1905,7 @@ export function inferBlockSchema(plan, schemas) {
             expression.name === "AVG" ||
             expression.name === "MIN" ||
             expression.name === "MAX" ||
+            expression.name === "MINNOW_SINGLE_VALUE" ||
             expression.name === "COALESCE" ||
             expression.name === "NULLIF" ||
             expression.name === "GREATEST" ||
@@ -3514,10 +3531,10 @@ function executeRowQueryInternal(plan, tables, memory) {
         // Only a wildcard select needs the source shapes: every other select resolves against its
         // own output aliases.
         const orderSources = plan.select[0]?.expression.kind === "wildcard"
-            ? [plan.base, ...plan.joins].map((source) => ({
-                alias: source.alias,
-                columns: rowTableColumnNames(tables.get(source.table) ?? []),
-            }))
+            ? [plan.base, ...plan.joins].flatMap((source) => {
+                const columns = rowTableColumnNames(tables.get(source.table) ?? []).filter((name) => !name.startsWith("\0"));
+                return columns.length === 0 ? [] : [{ alias: source.alias, columns }];
+            })
             : [];
         const sortColumns = plan.orderBy.map(({ expression, direction, nulls }) => ({
             outputName: orderOutputName(expression, plan.select, orderSources),
@@ -3700,11 +3717,10 @@ function isSqlJoinKey(value) {
 }
 function project(select, context, group) {
     if (select[0]?.expression.kind === "wildcard") {
-        const aliases = Object.keys(context);
-        return Object.fromEntries(aliases.flatMap((alias) => Object.entries(context[alias] ?? {}).map(([name, value]) => [
-            aliases.length === 1 ? name : `${alias}.${name}`,
-            value,
-        ])));
+        const aliases = Object.keys(context).filter((alias) => Object.keys(context[alias] ?? {}).some((name) => !name.startsWith("\0")));
+        return Object.fromEntries(aliases.flatMap((alias) => Object.entries(context[alias] ?? {})
+            .filter(([name]) => !name.startsWith("\0"))
+            .map(([name, value]) => [aliases.length === 1 ? name : `${alias}.${name}`, value])));
     }
     return Object.fromEntries(select.map((item) => [item.alias, asQueryValue(evaluate(item.expression, context, group))]));
 }
@@ -3788,6 +3804,13 @@ function evaluate(expression, context, group) {
                 if (group === undefined)
                     throw new TypeError(`${expression.name} requires grouped execution`);
                 const argument = expression.arguments[0] ?? { kind: "wildcard" };
+                if (expression.name === "MINNOW_SINGLE_VALUE") {
+                    if (group.length > 1) {
+                        throw new TypeError(`A scalar subquery returned ${String(group.length)} rows`);
+                    }
+                    const row = group[0];
+                    return row === undefined ? null : evaluate(argument, row);
+                }
                 if (expression.name === "STRING_AGG") {
                     const delimiter = expression.arguments[1];
                     if (delimiter === undefined)
@@ -3845,12 +3868,44 @@ function evaluate(expression, context, group) {
                             String(externalSqlDomainValue(member.value)))
                         .join(""));
                 }
+                if (expression.name === "JSON_ARRAYAGG") {
+                    let members = group.map((row) => ({
+                        value: argument.kind === "wildcard" ? 1 : evaluate(argument, row),
+                        order: (expression.aggregateOrderBy ?? []).map((item) => evaluate(item.expression, row)),
+                    }));
+                    if (expression.distinct === true) {
+                        const seen = new Set();
+                        members = members.filter(({ value }) => {
+                            const key = value instanceof Date ? ` d${String(dateMilliseconds(value))}` : value;
+                            if (seen.has(key))
+                                return false;
+                            seen.add(key);
+                            return true;
+                        });
+                    }
+                    if ((expression.aggregateOrderBy?.length ?? 0) > 0) {
+                        members.sort((left, right) => {
+                            for (const [index, order] of (expression.aggregateOrderBy ?? []).entries()) {
+                                const a = left.order[index];
+                                const b = right.order[index];
+                                const placed = nullOrder(a, b, order.nulls, order.direction);
+                                if (placed !== undefined && placed !== 0)
+                                    return placed;
+                                const compared = compareValues(a, b);
+                                if (compared !== 0)
+                                    return order.direction === "desc" ? -compared : compared;
+                            }
+                            return 0;
+                        });
+                    }
+                    return members.length === 0
+                        ? null
+                        : preservedJsonDomainValue(jsonConstructor("JSON_ARRAY", members.map(({ value }) => value)));
+                }
                 let values = argument.kind === "wildcard"
                     ? group.map(() => 1)
                     : group.map((row) => evaluate(argument, row));
-                if (expression.name !== "JSON_ARRAYAGG") {
-                    values = values.filter((value) => value !== null && value !== undefined);
-                }
+                values = values.filter((value) => value !== null && value !== undefined);
                 if (expression.distinct === true) {
                     const seen = new Set();
                     values = values.filter((value) => {
@@ -3872,11 +3927,6 @@ function evaluate(expression, context, group) {
                             const sum = sumNumericValues(values);
                             return exactNumericBinary("/", sum, values.length) ?? numeric(sum) / values.length;
                         })();
-                if (expression.name === "JSON_ARRAYAGG") {
-                    return values.length === 0
-                        ? null
-                        : JSON.stringify(values.map((value) => jsonValueOf(value ?? null)));
-                }
                 if (expression.name === "MIN")
                     return values.reduce((best, value) => (best === undefined || compareValues(value, best) < 0 ? value : best), undefined);
                 return values.reduce((best, value) => (best === undefined || compareValues(value, best) > 0 ? value : best), undefined);
@@ -4328,6 +4378,10 @@ export function hasAggregate(expression) {
     }
     return childExpressions(expression).some(hasAggregate);
 }
+/** One root aggregate call, using the same canonical set as parsing and execution. */
+export function isAggregateCall(expression) {
+    return expression.kind === "call" && aggregateNames.has(expression.name);
+}
 function validateGrouping(plan) {
     const grouped = plan.groupBy.length > 0 || plan.select.some((item) => hasAggregate(item.expression));
     if (!grouped)
@@ -4861,6 +4915,7 @@ class Parser {
             const columnType = this.#columnType();
             let nullable = true;
             let defaultValue;
+            let generatedValue;
             for (;;) {
                 if (this.#isKeyword("DEFAULT")) {
                     // PostgreSQL-compatible variable-free scalar expression, retained in the catalog.
@@ -4868,6 +4923,10 @@ class Parser {
                     defaultValue = this.#columnDefault();
                     continue;
                 }
+                if (this.#isKeyword("GENERATED")) {
+                    generatedValue = this.#generatedColumn();
+                    continue;
+                }
                 if (this.#isKeyword("CHECK")) {
                     checks.push(this.#checkConstraint(`${table}_${name}_check`));
                     continue;
@@ -4913,6 +4972,7 @@ class Parser {
                 ...columnType,
                 ...(nullable ? { nullable: true } : {}),
                 ...(defaultValue === undefined ? {} : { defaultValue }),
+                ...(generatedValue === undefined ? {} : { generatedValue }),
             });
             if (!this.#punctuation(","))
                 break;
@@ -4938,6 +4998,23 @@ class Parser {
                 }
             }
         }
+        for (const column of columns) {
+            if (column.defaultValue !== undefined && column.generatedValue !== undefined) {
+                throw new TypeError(`Generated column ${column.name} cannot also have a DEFAULT`);
+            }
+            if (column.generatedValue === undefined)
+                continue;
+            for (const reference of expressionColumnNames(compileCheckExpression(column.generatedValue.sql, `generated ${table}.${column.name}`))) {
+                const referencedName = reference.split(".").at(-1) ?? reference;
+                const referenced = columns.find(({ name }) => name === referencedName);
+                if (referenced === undefined) {
+                    throw new TypeError(`Generated column ${column.name} refers to a column this table has no: ${referencedName}`);
+                }
+                if (referenced === column || referenced.generatedValue !== undefined) {
+                    throw new TypeError(`Generated column ${column.name} cannot reference a generated column: ${referencedName}`);
+                }
+            }
+        }
         // Preserve the released single-UNIQUE row-addressing behavior when no PRIMARY KEY was
         // declared. Additional UNIQUE constraints remain independently enforced secondary keys.
         const promotedUnique = primaryKey === undefined && uniqueConstraints[0]?.columns.length === 1
@@ -5060,6 +5137,23 @@ class Parser {
             throw new TypeError("DEFAULT requires an expression");
         return columnDefaultFor(expression, sql);
     }
+    /** GENERATED [ALWAYS] AS (expression) STORED. */
+    #generatedColumn() {
+        this.#keyword("GENERATED");
+        if (this.#isKeyword("ALWAYS"))
+            this.#keyword("ALWAYS");
+        this.#keyword("AS");
+        const open = this.#peek();
+        this.#expectPunctuation("(");
+        const expression = this.#expression();
+        const close = this.#peek();
+        this.#expectPunctuation(")");
+        this.#keyword("STORED");
+        if (hasAggregate(expression) || containsWindow(expression) || containsParameter(expression)) {
+            throw new TypeError("Generated columns take an immutable row expression");
+        }
+        return { kind: "stored", sql: this.text.slice(open.start + 1, close.start).trim() };
+    }
     /** DROP VIEW [IF EXISTS] name (F031-16). */
     parseDropView() {
         this.#keyword("DROP");
@@ -5294,7 +5388,7 @@ class Parser {
                 rows: [[]],
                 defaultValues: true,
                 ...this.#onConflictClause(table),
-                ...this.#returningClause(),
+                ...this.#returningClause(table),
             };
         }
         if (this.#isKeyword("SELECT")) {
@@ -5311,7 +5405,7 @@ class Parser {
                 columns,
                 rows: [],
                 query,
-                ...this.#returningClause(),
+                ...this.#returningClause(table),
             };
         }
         this.#keyword("VALUES");
@@ -5338,7 +5432,7 @@ class Parser {
             columns,
             rows,
             ...this.#onConflictClause(table),
-            ...this.#returningClause(),
+            ...this.#returningClause(table),
         };
     }
     #onConflictClause(table) {
@@ -5405,8 +5499,8 @@ class Parser {
             },
         };
     }
-    /** RETURNING * or RETURNING col, ... — the engine's runStatement implements the semantics. */
-    #returningClause() {
+    /** RETURNING *, target.*, or [target.]col, ... — execution owns the row semantics. */
+    #returningClause(table) {
         if (!this.#isKeyword("RETURNING"))
             return {};
         this.#keyword("RETURNING");
@@ -5416,7 +5510,23 @@ class Parser {
         }
         const columns = [];
         for (;;) {
-            columns.push(this.#identifier());
+            const first = this.#identifier();
+            if (this.#punctuation(".")) {
+                if (first !== table) {
+                    throw new TypeError(`RETURNING qualifier must name the target table: ${table}`);
+                }
+                if (this.#peek().text === "*") {
+                    this.#index += 1;
+                    if (columns.length > 0 || this.#peek().text === ",") {
+                        throw new TypeError("RETURNING target.* must be the only returned item");
+                    }
+                    return { returning: "*" };
+                }
+                columns.push(this.#identifier());
+            }
+            else {
+                columns.push(first);
+            }
             if (!this.#punctuation(","))
                 break;
         }
@@ -5567,14 +5677,14 @@ class Parser {
             throw new TypeError("UPDATE assignments must set each column once");
         }
         const predicates = this.#mutationPredicates();
-        return { kind: "update", table, assignments, predicates, ...this.#returningClause() };
+        return { kind: "update", table, assignments, predicates, ...this.#returningClause(table) };
     }
     #deleteStatement() {
         this.#keyword("DELETE");
         this.#keyword("FROM");
         const table = this.#identifier();
         const predicates = this.#mutationPredicates();
-        return { kind: "delete", table, predicates, ...this.#returningClause() };
+        return { kind: "delete", table, predicates, ...this.#returningClause(table) };
     }
     #mutationPredicates() {
         const predicates = [];
@@ -6749,10 +6859,18 @@ class Parser {
                 const all = this.#isKeyword("ALL");
                 this.#keyword(this.#isKeyword("ANY") ? "ANY" : all ? "ALL" : "SOME");
                 this.#expectPunctuation("(");
+                // Kysely's fn.any(subquery) emits PostgreSQL's valid ANY((SELECT ...)) spelling.
+                let wrapped = 0;
+                while (this.#punctuation("("))
+                    wrapped += 1;
                 if (!this.#isKeyword("SELECT")) {
                     throw new TypeError("ANY/ALL take a subquery");
                 }
                 const block = this.#selectBlock("(quantified subquery)");
+                while (wrapped > 0) {
+                    this.#expectPunctuation(")");
+                    wrapped -= 1;
+                }
                 this.#expectPunctuation(")");
                 return {
                     kind: "condition",
@@ -7254,7 +7372,9 @@ class Parser {
             // canonical plan names. ANY_VALUE picks an implementation-dependent row of the group
             // (T626); MIN is one such choice and reuses its accumulator exactly.
             const name = (upper === "ANY_VALUE" ? "MIN" : (functionSpellings.get(upper) ?? upper));
-            if (name === "MINNOW_TUPLE_KEY" || name === "MINNOW_COLLATE") {
+            if (name === "MINNOW_TUPLE_KEY" ||
+                name === "MINNOW_COLLATE" ||
+                name === "MINNOW_SINGLE_VALUE") {
                 throw new TypeError(`Unsupported function: ${identifier}`);
             }
             if (!aggregateNames.has(name) && !scalarFunctionNames.has(name))
@@ -7285,6 +7405,11 @@ class Parser {
                     if (this.#isKeyword("ORDER"))
                         aggregateOrderBy = this.#orderByClause();
                 }
+                else if (name === "JSON_ARRAYAGG") {
+                    args.push(this.#expression());
+                    if (this.#isKeyword("ORDER"))
+                        aggregateOrderBy = this.#orderByClause();
+                }
                 else {
                     args.push(...this.#expressionList());
                 }
@@ -7737,8 +7862,8 @@ class Parser {
 /**
  * GROUPING SETS desugar: one grouped block per set, combined with UNION ALL. A grouped column
  * absent from a member's set projects as NULLIF(expr, expr) — always NULL, but carrying the
- * expression's type through schema inference. The GROUPING() marker function is deliberately
- * unsupported, so rollup NULLs and data NULLs are indistinguishable; the docs call this out.
+ * expression's type through schema inference. GROUPING() becomes one constant bitmask per member
+ * block, distinguishing columns aggregated away by the set from data NULLs.
  */
 function desugarGroupingSets(parts, nextSequence) {
     const { groupingSets, limit, offset, limitParameter, offsetParameter, ...blockParts } = parts;
@@ -8008,16 +8133,17 @@ export function assembleSelectBlock(parts, nextSequence) {
 export function expandDistinctWildcard(plan, columnsOf) {
     if (plan.distinctWildcard !== true)
         return plan;
-    const sources = [plan.base, ...plan.joins];
-    const multiple = sources.length > 1;
-    const select = sources.flatMap((source) => {
-        const columns = columnsOf(source.table);
-        if (columns === undefined || columns.length === 0) {
+    const shaped = [plan.base, ...plan.joins].map((source) => ({
+        source,
+        columns: sourceWildcardColumns(source, columnsOf),
+    }));
+    const visible = shaped.filter(({ columns }) => (columns?.length ?? 0) > 0);
+    const multiple = visible.length > 1;
+    const select = visible.flatMap(({ source, columns }) => {
+        if (columns === undefined) {
             throw new TypeError(`SELECT DISTINCT * requires known columns for: ${source.table}`);
         }
-        return columns
-            .filter((name) => !name.startsWith("\0"))
-            .map((name) => {
+        return columns.map((name) => {
             const output = multiple ? `${source.alias}.${name}` : name;
             return { expression: { kind: "column", reference: output }, alias: output };
         });
@@ -8113,10 +8239,12 @@ export function withTiesPlan(plan) {
         return { plan, trim: (result) => result };
     if (plan.orderBy.length === 0)
         throw new TypeError("FETCH ... WITH TIES requires ORDER BY");
-    const sources = [plan.base, ...plan.joins].map((source) => ({
-        alias: source.alias,
-        columns: source.derived?.select.map((item) => item.alias) ?? [],
-    }));
+    const sources = [plan.base, ...plan.joins].flatMap((source) => {
+        const columns = source.derived?.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+        return columns?.length === 0 ? [] : [{ alias: source.alias, columns: columns ?? [] }];
+    });
     // orderOutputName throws when a sort key has no output column, which is the same failure the
     // executors report; nothing here has to re-check it.
     const keys = plan.orderBy.map(({ expression }) => orderOutputName(expression, plan.select, sources));
@@ -8296,7 +8424,8 @@ export function expandQualifiedWildcards(plan, columnsOf) {
     const expandBlock = (block) => {
         forEachNestedBlock(block, expandBlock);
         const sources = [block.base, ...block.joins];
-        const multiple = sources.length > 1;
+        const multiple = sources.filter((source) => (sourceWildcardColumns(source, columnsOf)?.length ?? 0) > 0)
+            .length > 1;
         block.select = block.select.flatMap((item) => {
             if (item.expression.kind !== "wildcard" || item.expression.table === undefined)
                 return [item];
@@ -8386,9 +8515,9 @@ function assembleOrderByExpressionBlock(parts, nextSequence) {
             throw new TypeError("Window functions are only allowed in the select list");
         }
         // A bare literal is almost always a SQL ordinal (ORDER BY 2); sorting by a constant would
-        // silently do nothing, so reject it the way the engine always has.
+        // silently do nothing. Valid ordinals have already resolved; a remaining literal is invalid.
         if (order.expression.kind === "literal") {
-            throw new TypeError("ORDER BY ordinals are not supported; name the column or alias");
+            throw new TypeError("ORDER BY position is outside the select list");
         }
     }
     const selectSignatures = new Map(parts.select.map((item) => [JSON.stringify(item.expression), item.alias]));

package/dist/engine/schema-wire.d.ts

@@ -1,4 +1,4 @@
-import type { ColumnDefault, SqlDomain } from "../storage/types.js";
+import type { ColumnDefault, ColumnGenerated, SqlDomain } from "../storage/types.js";
 import { type AnyTable, type MigrationStep, type ReferentialAction, type SchemaColumnType, type SchemaDefinition, type TableCheck, type TableForeignKey } from "./schema.js";
 /**
  * Structured-clone-safe mirror of the schema DSL. Column builders and table validators carry
@@ -12,6 +12,7 @@ export interface WireColumn {
     readonly integer?: true;
     readonly sqlDomain?: SqlDomain;
     readonly defaultSpec?: ColumnDefault;
+    readonly generatedSpec?: ColumnGenerated;
     readonly renamedFromName?: string;
     readonly reference?: {
         table: string;
@@ -84,6 +85,11 @@ export type WireMigrationStep = {
     tableName: string;
     columnName: string;
     defaultValue: ColumnDefault | null;
+} | {
+    kind: "alter-generated";
+    tableName: string;
+    columnName: string;
+    generatedValue: ColumnGenerated | null;
 } | {
     kind: "alter-foreign-keys";
     tableName: string;

package/dist/engine/schema-wire.js

@@ -14,6 +14,9 @@ function serializeColumn(definition, frozen) {
             ? {}
             : { sqlDomain: structuredClone(definition.sqlDomain) }),
         ...(definition.defaultSpec === undefined ? {} : { defaultSpec: { ...definition.defaultSpec } }),
+        ...(definition.generatedSpec === undefined
+            ? {}
+            : { generatedSpec: { ...definition.generatedSpec } }),
         ...(definition.renamedFromName === undefined
             ? {}
             : { renamedFromName: definition.renamedFromName }),
@@ -95,6 +98,7 @@ function deserializeColumn(wire) {
         integer: wire.integer === true,
         ...(wire.sqlDomain === undefined ? {} : { sqlDomain: structuredClone(wire.sqlDomain) }),
         ...(wire.defaultSpec === undefined ? {} : { defaultSpec: wire.defaultSpec }),
+        ...(wire.generatedSpec === undefined ? {} : { generatedSpec: wire.generatedSpec }),
         ...(wire.renamedFromName === undefined ? {} : { renamedFromName: wire.renamedFromName }),
         ...(wire.reference === undefined
             ? {}