@syncular/typegen 0.4.0 → 0.5.0

package/dist/syql-template-parser.js

@@ -0,0 +1,350 @@
+/** Embedded SQL-template node parser for revision-1 SYQL (§§6, 8, and 10). */
+import { isSyqlTrivia, SyqlFrontendError, } from './syql-lexer.js';
+const CAMEL_IDENT_RE = /^[a-z][A-Za-z0-9]*$/;
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function spanBetween(start, end) {
+    return {
+        file: start.span.file,
+        start: start.span.start,
+        end: end.span.end,
+    };
+}
+function emptySpanAtStart(span) {
+    return { file: span.file, start: span.start, end: span.start };
+}
+class EmbeddedParser {
+    #file;
+    #tokens;
+    #span;
+    #mode;
+    #index = 0;
+    constructor(file, tokens, span, mode) {
+        this.#file = file;
+        this.#tokens = tokens;
+        this.#span = span;
+        this.#mode = mode;
+    }
+    parse() {
+        const nodes = [];
+        let rawStart = 0;
+        while (this.#index < this.#tokens.length) {
+            const next = this.#peek();
+            if (next === undefined)
+                break;
+            this.#index = next.index;
+            const embeddedKind = this.#embeddedKind(next.token);
+            if (embeddedKind !== undefined) {
+                this.#pushRaw(nodes, rawStart, next.index);
+                if (embeddedKind === 'when')
+                    nodes.push(this.#parseWhen());
+                else if (embeddedKind === 'scope' || embeddedKind === 'cover') {
+                    nodes.push(this.#parseDirective(embeddedKind));
+                }
+                else {
+                    nodes.push(this.#parsePredicateCall());
+                }
+                rawStart = this.#index;
+                continue;
+            }
+            this.#validateRawToken(next.token);
+            this.#index = next.index + 1;
+        }
+        this.#pushRaw(nodes, rawStart, this.#tokens.length);
+        return { kind: 'template', mode: this.#mode, nodes, span: this.#span };
+    }
+    #embeddedKind(token) {
+        if (token.kind === 'at-identifier') {
+            if (token.text === '@scope')
+                return 'scope';
+            if (token.text === '@cover')
+                return 'cover';
+            return 'predicate-call';
+        }
+        if (token.kind === 'identifier' &&
+            token.text === 'when' &&
+            this.#peekAfter(token)?.token.text === '(') {
+            return 'when';
+        }
+        return undefined;
+    }
+    #parsePredicateCall() {
+        const startIndex = this.#index;
+        const nameToken = this.#take();
+        if (this.#mode === 'order') {
+            this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', nameToken, 'predicate calls are not allowed in sort profiles');
+        }
+        const name = nameToken.text.slice(1);
+        if (!CAMEL_IDENT_RE.test(name) || name.toLowerCase().startsWith('__syql')) {
+            this.#fail('SYQL3003_INVALID_PREDICATE_CALL', nameToken, `predicate call name ${JSON.stringify(name)} must match [a-z][A-Za-z0-9]* and not use __syql`);
+        }
+        this.#expectText('(', 'after predicate name');
+        const args = [];
+        if (this.#peek()?.token.text !== ')') {
+            for (;;) {
+                args.push(this.#parseBindReference());
+                if (this.#peek()?.token.text !== ',')
+                    break;
+                this.#take();
+                if (this.#peek()?.token.text === ')')
+                    break;
+            }
+        }
+        const close = this.#expectText(')', 'to close predicate call');
+        return {
+            kind: 'predicate-call',
+            name,
+            arguments: args,
+            tokens: this.#tokens.slice(startIndex, this.#index),
+            span: spanBetween(nameToken, close),
+        };
+    }
+    #parseWhen() {
+        const startIndex = this.#index;
+        const start = this.#take();
+        if (this.#mode !== 'statement') {
+            this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', start, `when is not allowed in a ${this.#mode} template`);
+        }
+        this.#expectText('(', 'after when');
+        const controls = [];
+        const controlSpans = [];
+        const seen = new Set();
+        if (this.#peek()?.token.text === ')') {
+            this.#fail('SYQL3004_INVALID_WHEN', this.#peek()?.token ?? start, 'when requires at least one control');
+        }
+        for (;;) {
+            const control = this.#expectIdentifier('when control');
+            this.#validateCamel(control, 'when control', 'SYQL3004_INVALID_WHEN');
+            if (seen.has(control.text)) {
+                this.#fail('SYQL3004_INVALID_WHEN', control, `duplicate when control ${JSON.stringify(control.text)}`);
+            }
+            seen.add(control.text);
+            controls.push(control.text);
+            controlSpans.push(control.span);
+            if (this.#peek()?.token.text !== ',')
+                break;
+            this.#take();
+            if (this.#peek()?.token.text === ')')
+                break;
+        }
+        this.#expectText(')', 'after when controls');
+        const open = this.#expectText('{', 'to open when body');
+        const closeIndex = this.#matchingBraceIndex(open);
+        const close = this.#tokens[closeIndex];
+        const bodyTokens = this.#tokens.slice(this.#index, closeIndex);
+        if (bodyTokens.every(isSyqlTrivia)) {
+            this.#fail('SYQL3004_INVALID_WHEN', close, 'when body must not be empty');
+        }
+        const bodySpan = {
+            file: this.#file,
+            start: open.span.end,
+            end: close.span.start,
+        };
+        const body = parseSyqlEmbeddedTemplate(this.#file, bodyTokens, bodySpan, 'condition');
+        this.#index = closeIndex + 1;
+        return {
+            kind: 'when',
+            controls,
+            controlSpans,
+            body,
+            tokens: this.#tokens.slice(startIndex, this.#index),
+            span: spanBetween(start, close),
+        };
+    }
+    #parseDirective(kind) {
+        const startIndex = this.#index;
+        const start = this.#take();
+        if (this.#mode !== 'statement') {
+            this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', start, `@${kind} is not allowed in a ${this.#mode} template`);
+        }
+        this.#expectText('(', `after @${kind}`);
+        const bindings = [];
+        if (this.#peek()?.token.text === ')') {
+            this.#fail('SYQL3005_INVALID_REACTIVE_DIRECTIVE', this.#peek()?.token ?? start, `@${kind} requires at least one scope binding`);
+        }
+        for (;;) {
+            bindings.push(this.#parseScopeBinding());
+            if (this.#peek()?.token.text !== ',')
+                break;
+            this.#take();
+            if (this.#peek()?.token.text === ')')
+                break;
+        }
+        const close = this.#expectText(')', `to close @${kind}`);
+        return {
+            kind,
+            bindings,
+            tokens: this.#tokens.slice(startIndex, this.#index),
+            span: spanBetween(start, close),
+        };
+    }
+    #parseScopeBinding() {
+        const qualifier = this.#expectIdentifier('scope table or alias');
+        this.#validateSqlIdent(qualifier, 'scope table or alias');
+        this.#expectText('.', 'in qualified scope column');
+        const columnName = this.#expectIdentifier('scope column');
+        this.#validateSqlIdent(columnName, 'scope column');
+        const column = {
+            qualifier: qualifier.text,
+            name: columnName.text,
+            span: spanBetween(qualifier, columnName),
+        };
+        const operator = this.#take();
+        if (operator === undefined ||
+            (operator.text !== '=' && operator.text !== 'in')) {
+            this.#fail('SYQL3005_INVALID_REACTIVE_DIRECTIVE', operator ?? columnName, 'scope binding must use = or lowercase in');
+        }
+        const values = [];
+        let end;
+        if (operator.text === '=') {
+            const value = this.#parseBindReference();
+            values.push(value);
+            end = value.token;
+        }
+        else {
+            this.#expectText('(', 'after scope in');
+            if (this.#peek()?.token.text === ')') {
+                this.#fail('SYQL3005_INVALID_REACTIVE_DIRECTIVE', this.#peek()?.token ?? operator, 'scope in list must not be empty');
+            }
+            const names = new Set();
+            for (;;) {
+                const value = this.#parseBindReference();
+                if (names.has(value.name)) {
+                    this.#fail('SYQL3005_INVALID_REACTIVE_DIRECTIVE', value.token, `duplicate scope bind :${value.name}`);
+                }
+                names.add(value.name);
+                values.push(value);
+                if (this.#peek()?.token.text !== ',')
+                    break;
+                this.#take();
+                if (this.#peek()?.token.text === ')')
+                    break;
+            }
+            end = this.#expectText(')', 'to close scope in list');
+        }
+        return {
+            kind: 'scope-binding',
+            column,
+            operator: operator.text === '=' ? 'equal' : 'in',
+            values,
+            span: spanBetween(qualifier, end),
+        };
+    }
+    #parseBindReference() {
+        const token = this.#take();
+        if (token?.kind !== 'bind') {
+            this.#fail('SYQL3002_INVALID_BIND', token ?? this.#tokens[this.#tokens.length - 1], 'expected a :camelCase bind reference');
+        }
+        const name = token.text.slice(1);
+        if (!CAMEL_IDENT_RE.test(name) || name.toLowerCase().startsWith('__syql')) {
+            this.#fail('SYQL3002_INVALID_BIND', token, `bind ${JSON.stringify(token.text)} must match :[a-z][A-Za-z0-9]* and not use __syql`);
+        }
+        return { kind: 'bind-reference', name, token, span: token.span };
+    }
+    #validateRawToken(token) {
+        if (token.kind === 'bind') {
+            if (this.#mode === 'order') {
+                this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', token, 'binds are not allowed in sort profiles');
+            }
+            const name = token.text.slice(1);
+            if (!CAMEL_IDENT_RE.test(name) ||
+                name.toLowerCase().startsWith('__syql')) {
+                this.#fail('SYQL3002_INVALID_BIND', token, `bind ${JSON.stringify(token.text)} must match :[a-z][A-Za-z0-9]* and not use __syql`);
+            }
+        }
+        if (token.kind === 'punctuation' && token.text === '?') {
+            this.#fail('SYQL3008_FORBIDDEN_PARAMETER_FORM', token, 'SQLite ? parameters are forbidden; declare and use a :camelCase bind');
+        }
+        if (token.kind === 'operator' &&
+            (token.text === '$' || token.text === '@')) {
+            this.#fail('SYQL3008_FORBIDDEN_PARAMETER_FORM', token, `SQLite ${token.text} parameters are forbidden in SYQL templates`);
+        }
+        if (token.kind === 'punctuation' &&
+            (token.text === '{' || token.text === '}')) {
+            this.#fail('SYQL3007_UNEXPECTED_BRACE', token, 'a template brace must belong to a when(...) { ... } node');
+        }
+    }
+    #validateCamel(token, label, code) {
+        if (!CAMEL_IDENT_RE.test(token.text) ||
+            token.text.toLowerCase().startsWith('__syql')) {
+            this.#fail(code, token, `${label} must match [a-z][A-Za-z0-9]* and not use __syql`);
+        }
+    }
+    #validateSqlIdent(token, label) {
+        if (!IDENT_RE.test(token.text)) {
+            this.#fail('SYQL3005_INVALID_REACTIVE_DIRECTIVE', token, `${label} must be an unquoted SQLite identifier`);
+        }
+    }
+    #matchingBraceIndex(open) {
+        let depth = 1;
+        for (let cursor = this.#index; cursor < this.#tokens.length; cursor += 1) {
+            const token = this.#tokens[cursor];
+            if (token.kind !== 'punctuation')
+                continue;
+            if (token.text === '{')
+                depth += 1;
+            else if (token.text === '}') {
+                depth -= 1;
+                if (depth === 0)
+                    return cursor;
+            }
+        }
+        this.#fail('SYQL3001_EXPECTED_EMBEDDED_TOKEN', open, 'expected } to close when body');
+    }
+    #pushRaw(nodes, start, end) {
+        if (start >= end)
+            return;
+        const tokens = this.#tokens.slice(start, end);
+        const first = tokens[0];
+        const last = tokens[tokens.length - 1];
+        nodes.push({
+            kind: 'raw',
+            text: tokens.map((token) => token.text).join(''),
+            tokens,
+            span: spanBetween(first, last),
+        });
+    }
+    #peek(from = this.#index) {
+        let index = from;
+        while (index < this.#tokens.length) {
+            const token = this.#tokens[index];
+            if (!isSyqlTrivia(token))
+                return { index, token };
+            index += 1;
+        }
+        return undefined;
+    }
+    #peekAfter(token) {
+        const index = this.#tokens.indexOf(token, this.#index);
+        return index < 0 ? undefined : this.#peek(index + 1);
+    }
+    #take() {
+        const next = this.#peek();
+        if (next === undefined) {
+            this.#index = this.#tokens.length;
+            return undefined;
+        }
+        this.#index = next.index + 1;
+        return next.token;
+    }
+    #expectText(text, context) {
+        const token = this.#take();
+        if (token?.text !== text) {
+            this.#fail('SYQL3001_EXPECTED_EMBEDDED_TOKEN', token ?? this.#tokens[this.#tokens.length - 1], `expected ${JSON.stringify(text)} ${context}`);
+        }
+        return token;
+    }
+    #expectIdentifier(label) {
+        const token = this.#take();
+        if (token?.kind !== 'identifier') {
+            this.#fail('SYQL3001_EXPECTED_EMBEDDED_TOKEN', token ?? this.#tokens[this.#tokens.length - 1], `expected ${label}`);
+        }
+        return token;
+    }
+    #fail(code, token, message) {
+        throw new SyqlFrontendError(code, token?.span ?? emptySpanAtStart(this.#span), message);
+    }
+}
+/** Parse embedded nodes from one already-delimited lossless template. */
+export function parseSyqlEmbeddedTemplate(file, tokens, span, mode) {
+    return new EmbeddedParser(file, tokens, span, mode).parse();
+}

package/dist/syql.d.ts

@@ -17,6 +17,20 @@ export interface SyqlLimit {
     readonly max?: number;
     readonly default?: number;
 }
+export interface SyqlDepends {
+    readonly table: string;
+    readonly variable: string;
+    readonly params: readonly string[];
+}
+export interface SyqlWindow {
+    readonly table: string;
+    readonly variable: string;
+    readonly units: readonly string[];
+    readonly fixedScopes: readonly {
+        readonly variable: string;
+        readonly param: string;
+    }[];
+}
 export interface SyqlFragmentDecl {
     readonly name: string;
     readonly params: readonly SyqlParamDecl[];
@@ -33,6 +47,11 @@ export interface SyqlQueryDecl {
     /** §7 opt-in: lower to 2^N enumerated statements (perfect index use)
      * instead of one neutralized statement. API-invisible. */
     readonly variants?: boolean;
+    /** Checked escape hatches for SQL shapes the conservative analyzer cannot
+     * prove. They live with the query, never in React application code. */
+    readonly depends?: readonly SyqlDepends[];
+    readonly windows?: readonly SyqlWindow[];
+    readonly keyBy?: readonly string[];
     /** The SQL-shaped body (may contain @fragment refs and if-guards). */
     readonly body: string;
     /** Source offset of the `query` keyword (editor tooling). */

package/dist/syql.js

@@ -234,6 +234,17 @@ function parseKnobs(cur, owner) {
     let orderBy;
     let limit;
     let variants;
+    const depends = [];
+    const windows = [];
+    let keyBy;
+    const paramList = (label) => {
+        const out = [cur.word(`${owner}: ${label} param`)];
+        while (cur.peekChar() === '|') {
+            cur.expect('|');
+            out.push(cur.word(`${owner}: ${label} param`));
+        }
+        return out;
+    };
     for (;;) {
         const word = cur.peekWord();
         if (word === 'variants') {
@@ -242,6 +253,49 @@ function parseKnobs(cur, owner) {
             cur.word('variants');
             variants = true;
         }
+        else if (word === 'depends') {
+            cur.word('depends');
+            const table = cur.word(`${owner}: dependency table`);
+            const on = cur.word(`${owner}: dependency \`on\``);
+            if (on !== 'on')
+                cur.fail(`${owner}: depends syntax is \`depends <table> on <scope> = <param>\``);
+            const variable = cur.word(`${owner}: dependency scope variable`);
+            cur.expect('=');
+            depends.push({ table, variable, params: paramList('dependency') });
+        }
+        else if (word === 'window') {
+            cur.word('window');
+            const table = cur.word(`${owner}: window table`);
+            const by = cur.word(`${owner}: window \`by\``);
+            if (by !== 'by')
+                cur.fail(`${owner}: window syntax is \`window <table> by <scope> = <param>\``);
+            const variable = cur.word(`${owner}: window scope variable`);
+            cur.expect('=');
+            const units = paramList('window unit');
+            const fixedScopes = [];
+            if (cur.peekWord() === 'fixed') {
+                cur.word('fixed');
+                for (;;) {
+                    const fixedVariable = cur.word(`${owner}: fixed scope variable`);
+                    cur.expect('=');
+                    const param = cur.word(`${owner}: fixed scope param`);
+                    fixedScopes.push({ variable: fixedVariable, param });
+                    if (cur.peekChar() !== ',')
+                        break;
+                    cur.expect(',');
+                }
+            }
+            windows.push({ table, variable, units, fixedScopes });
+        }
+        else if (word === 'key') {
+            if (keyBy !== undefined)
+                cur.fail(`${owner}: duplicate key by declaration`);
+            cur.word('key');
+            const by = cur.word(`${owner}: key \`by\``);
+            if (by !== 'by')
+                cur.fail(`${owner}: key syntax is \`key by <result-column>\``);
+            keyBy = paramList('key column');
+        }
         else if (word === 'orderBy') {
             if (orderBy !== undefined)
                 cur.fail(`${owner}: duplicate orderBy knob`);
@@ -313,6 +367,9 @@ function parseKnobs(cur, owner) {
                 ...(orderBy !== undefined ? { orderBy } : {}),
                 ...(limit !== undefined ? { limit } : {}),
                 ...(variants !== undefined ? { variants } : {}),
+                ...(depends.length > 0 ? { depends } : {}),
+                ...(windows.length > 0 ? { windows } : {}),
+                ...(keyBy !== undefined ? { keyBy } : {}),
             };
         }
     }
@@ -717,6 +774,143 @@ export function lowerSyqlBody(decl, fragments, location) {
 // ---------------------------------------------------------------------------
 // Analysis (parse → lower → the shared SQLite-check pipeline)
 // ---------------------------------------------------------------------------
+function checkedReactiveMetadata(decl, base, params, ir, location) {
+    if (decl.depends === undefined &&
+        decl.windows === undefined &&
+        decl.keyBy === undefined) {
+        return base.reactive;
+    }
+    const paramByName = new Map(params.map((param) => [param.name, param]));
+    const explicitScopes = new Map();
+    const explicitTables = new Set();
+    const tableAndScope = (tableName, variable) => {
+        if (!base.tables.includes(tableName)) {
+            throw new TypegenError(location, `reactive declaration names table ${JSON.stringify(tableName)}, but the query does not read it`);
+        }
+        const table = ir.tables.find((candidate) => candidate.name === tableName);
+        if (table === undefined) {
+            throw new TypegenError(location, `unknown reactive table ${JSON.stringify(tableName)}`);
+        }
+        const scope = table.scopes.find((candidate) => candidate.variable === variable);
+        if (scope === undefined) {
+            throw new TypegenError(location, `table ${tableName} has no scope variable ${JSON.stringify(variable)}`);
+        }
+        return { table, scope };
+    };
+    const checkedParam = (tableName, variable, name) => {
+        const param = paramByName.get(name);
+        if (param === undefined) {
+            throw new TypegenError(location, `reactive declaration references undeclared param :${name}`);
+        }
+        if (param.optional === true) {
+            throw new TypegenError(location, `reactive scope ${tableName}.${variable} cannot use optional param :${name}; an absent value is not a window unit`);
+        }
+        const { table, scope } = tableAndScope(tableName, variable);
+        const column = table.columns.find((candidate) => candidate.name === scope.column);
+        if (column === undefined || column.type !== param.type) {
+            throw new TypegenError(location, `reactive param :${name} has type ${param.type}, incompatible with ${tableName}.${scope.column} (${column?.type ?? 'unknown'})`);
+        }
+        return param;
+    };
+    const addScope = (table, variable, names) => {
+        const { scope } = tableAndScope(table, variable);
+        explicitTables.add(table);
+        let byVariable = explicitScopes.get(table);
+        if (byVariable === undefined) {
+            byVariable = new Map();
+            explicitScopes.set(table, byVariable);
+        }
+        let binding = byVariable.get(variable);
+        if (binding === undefined) {
+            binding = { pattern: scope.pattern, params: new Set() };
+            byVariable.set(variable, binding);
+        }
+        for (const name of names) {
+            checkedParam(table, variable, name);
+            binding.params.add(name);
+        }
+    };
+    for (const dependency of decl.depends ?? []) {
+        addScope(dependency.table, dependency.variable, dependency.params);
+    }
+    const coverage = [];
+    const seenWindows = new Set();
+    for (const window of decl.windows ?? []) {
+        const key = `${window.table}\0${window.variable}`;
+        if (seenWindows.has(key)) {
+            throw new TypegenError(location, `duplicate window declaration for ${window.table}.${window.variable}`);
+        }
+        seenWindows.add(key);
+        const { table } = tableAndScope(window.table, window.variable);
+        addScope(window.table, window.variable, window.units);
+        const fixedByVariable = new Map();
+        for (const fixed of window.fixedScopes) {
+            if (fixed.variable === window.variable) {
+                throw new TypegenError(location, `window ${window.table}.${window.variable} repeats its unit scope as fixed`);
+            }
+            if (fixedByVariable.has(fixed.variable)) {
+                throw new TypegenError(location, `window ${window.table} repeats fixed scope ${fixed.variable}`);
+            }
+            checkedParam(window.table, fixed.variable, fixed.param);
+            fixedByVariable.set(fixed.variable, fixed.param);
+            addScope(window.table, fixed.variable, [fixed.param]);
+        }
+        const missing = table.scopes
+            .map((scope) => scope.variable)
+            .filter((variable) => variable !== window.variable && !fixedByVariable.has(variable));
+        if (missing.length > 0) {
+            throw new TypegenError(location, `window ${window.table}.${window.variable} must fix the remaining scope variables: ${missing.join(', ')}`);
+        }
+        coverage.push({
+            table: window.table,
+            variable: window.variable,
+            units: window.units,
+            fixedScopes: table.scopes
+                .filter((scope) => scope.variable !== window.variable)
+                .map((scope) => ({
+                variable: scope.variable,
+                params: [fixedByVariable.get(scope.variable)],
+            })),
+        });
+    }
+    const dependencies = base.reactive.dependencies.map((dependency) => {
+        if (!explicitTables.has(dependency.table))
+            return dependency;
+        const scopes = [...(explicitScopes.get(dependency.table)?.entries() ?? [])]
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([variable, binding]) => ({
+            table: dependency.table,
+            variable,
+            pattern: binding.pattern,
+            params: [...binding.params],
+        }));
+        return { table: dependency.table, scopes };
+    });
+    let rowKey = base.reactive.rowKey;
+    if (decl.keyBy !== undefined) {
+        const fields = decl.keyBy.map((name) => {
+            const column = base.columns.find((candidate) => candidate.name === name || candidate.langName === name);
+            if (column === undefined) {
+                throw new TypegenError(location, `key by column ${JSON.stringify(name)} is not projected by the query`);
+            }
+            return column.langName;
+        });
+        if (new Set(fields).size !== fields.length) {
+            throw new TypegenError(location, 'key by contains a duplicate result column');
+        }
+        rowKey = fields;
+    }
+    return {
+        dependencies,
+        coverage: decl.windows === undefined
+            ? base.reactive.coverage
+            : [
+                ...base.reactive.coverage.filter((item) => !seenWindows.has(`${item.table}\0${item.variable}`)),
+                ...coverage,
+            ],
+        ...(rowKey !== undefined ? { rowKey } : {}),
+    };
+}
 /** Analyze every query of one `.syql` file into `AnalyzedQuery` units —
  * byte-compatible with the `.sql` frontend's output (§1: nothing below the
  * IR knows the frontend). */
@@ -801,6 +995,7 @@ export function analyzeSyqlFile(relPath, content, ir, db, naming) {
         });
         const mode = naming?.naming ?? 'camel';
         const mapCol = (name) => mode === 'preserve' ? name : snakeToCamel(name);
+        const reactive = checkedReactiveMetadata(decl, base, params, ir, location);
         const orderBy = decl.orderBy === undefined
             ? undefined
             : {
@@ -932,6 +1127,7 @@ export function analyzeSyqlFile(relPath, content, ir, db, naming) {
             sourceSql: decl.body.trim(),
             sql: exposedSql,
             params,
+            reactive,
             ...(orderBy !== undefined ? { orderBy } : {}),
             ...(decl.limit !== undefined ? { limit: decl.limit } : {}),
             ...(positionalSqlBase !== undefined ? { positionalSqlBase } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Syncular schema-to-TypeScript type generator and the `syncular` CLI",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -48,7 +48,7 @@
     "!dist/**/*.test.d.ts"
   ],
   "devDependencies": {
-    "@syncular/core": "0.3.1",
-    "@syncular/server": "0.3.1"
+    "@syncular/core": "0.5.0",
+    "@syncular/server": "0.5.0"
   }
 }