@syncular/typegen 0.4.0 → 0.5.0

package/dist/query.js

@@ -298,17 +298,31 @@ function stripCommentsAndStrings(sql) {
         const next = sql[i + 1];
         if (ch === '-' && next === '-') {
             const end = sql.indexOf('\n', i);
-            i = end === -1 ? sql.length : end;
+            const stop = end === -1 ? sql.length : end;
+            out += ' '.repeat(stop - i);
+            i = stop;
         }
         else if (ch === '/' && next === '*') {
             const end = sql.indexOf('*/', i + 2);
-            i = end === -1 ? sql.length : end + 2;
-            out += ' ';
+            const stop = end === -1 ? sql.length : end + 2;
+            out += sql.slice(i, stop).replace(/[^\n]/g, ' ');
+            i = stop;
         }
         else if (ch === "'") {
-            const end = sql.indexOf("'", i + 1);
-            i = end === -1 ? sql.length : end + 1;
-            out += ' ';
+            let stop = i + 1;
+            while (stop < sql.length) {
+                if (sql[stop] === "'" && sql[stop + 1] === "'") {
+                    stop += 2;
+                    continue;
+                }
+                if (sql[stop] === "'") {
+                    stop += 1;
+                    break;
+                }
+                stop += 1;
+            }
+            out += sql.slice(i, stop).replace(/[^\n]/g, ' ');
+            i = stop;
         }
         else {
             out += ch;
@@ -507,7 +521,7 @@ function resolveSource(item, refs, ir) {
             return null;
         const table = byName.get(ref.table);
         const col = table?.columns.find((c) => c.name === columnName);
-        return col === undefined ? null : { column: col };
+        return col === undefined ? null : { table: ref.table, column: col };
     }
     // Unqualified: search every FROM/JOIN table (SQLite already resolved
     // ambiguity; a single-table query is the common case).
@@ -515,7 +529,7 @@ function resolveSource(item, refs, ir) {
         const table = byName.get(ref.table);
         const col = table?.columns.find((c) => c.name === columnName);
         if (col !== undefined)
-            return { column: col };
+            return { table: ref.table, column: col };
     }
     return null;
 }
@@ -598,6 +612,120 @@ function fallbackColumnType(expr) {
         return 'float';
     return 'string';
 }
+function inferReactiveMetadata(sql, refs, ir, params, columns) {
+    const conservative = /\b(?:UNION|EXCEPT|INTERSECT)\b/i.test(stripCommentsAndStrings(sql));
+    const requiredAt = (index) => {
+        const cleaned = stripCommentsAndStrings(sql);
+        const where = /\bWHERE\b/i.exec(cleaned);
+        if (where === null || index < where.index + where[0].length)
+            return false;
+        const matchStack = [];
+        for (let cursor = where.index + where[0].length; cursor < index; cursor += 1) {
+            if (cleaned[cursor] === '(')
+                matchStack.push(cursor);
+            else if (cleaned[cursor] === ')')
+                matchStack.pop();
+        }
+        const stack = [];
+        for (let cursor = where.index + where[0].length; cursor < cleaned.length; cursor += 1) {
+            const char = cleaned[cursor];
+            if (char === '(')
+                stack.push(cursor);
+            else if (char === ')')
+                stack.pop();
+            if (cursor > index &&
+                /^(?:GROUP\s+BY|ORDER\s+BY|LIMIT|HAVING)\b/i.test(cleaned.slice(cursor))) {
+                break;
+            }
+            if (/^OR\b/i.test(cleaned.slice(cursor)) &&
+                stack.every((open, stackIndex) => matchStack[stackIndex] === open)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const byParam = new Map(params.map((param) => [param.name, param]));
+    const dependencies = [];
+    const coverage = [];
+    for (const tableName of [...new Set(refs.map((ref) => ref.table))].sort()) {
+        const table = ir.tables.find((candidate) => candidate.name === tableName);
+        const tableRefs = refs.filter((ref) => ref.table === tableName);
+        const scopes = [];
+        if (table !== undefined && tableRefs.length === 1 && !conservative) {
+            const qualifier = tableRefs[0]?.alias;
+            for (const scope of table.scopes) {
+                const column = scope.column.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const qualified = qualifier === undefined
+                    ? `(?:${IDENT}\\.)?${column}`
+                    : `(?:${qualifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.)?${column}`;
+                const found = [];
+                const equality = new RegExp(`${qualified}\\s*(?:=|==|\\bIS\\b)\\s*:(${IDENT})\\b|:(${IDENT})\\b\\s*(?:=|==)\\s*${qualified}`, 'gi');
+                for (const match of sql.matchAll(equality)) {
+                    if (!requiredAt(match.index))
+                        continue;
+                    const name = match[1] ?? match[2];
+                    const param = name === undefined ? undefined : byParam.get(name);
+                    if (param !== undefined &&
+                        param.optional !== true &&
+                        param.flag !== true) {
+                        found.push(param.name);
+                    }
+                }
+                const inList = new RegExp(`${qualified}\\s+IN\\s*\\(([^)]*)\\)`, 'gi');
+                for (const match of sql.matchAll(inList)) {
+                    if (!requiredAt(match.index))
+                        continue;
+                    for (const paramMatch of (match[1] ?? '').matchAll(/:([A-Za-z_][A-Za-z0-9_]*)/g)) {
+                        const param = byParam.get(paramMatch[1]);
+                        if (param !== undefined &&
+                            param.optional !== true &&
+                            param.flag !== true) {
+                            found.push(param.name);
+                        }
+                    }
+                }
+                const unique = [...new Set(found)];
+                if (unique.length > 0) {
+                    scopes.push({
+                        table: tableName,
+                        variable: scope.variable,
+                        pattern: scope.pattern,
+                        params: unique,
+                    });
+                }
+            }
+            if (table.scopes.length > 0 && scopes.length === table.scopes.length) {
+                const variable = scopes[0];
+                coverage.push({
+                    table: tableName,
+                    variable: variable.variable,
+                    units: variable.params,
+                    fixedScopes: scopes.slice(1).map((scope) => ({
+                        variable: scope.variable,
+                        params: scope.params,
+                    })),
+                });
+            }
+        }
+        dependencies.push({ table: tableName, scopes });
+    }
+    let rowKey;
+    const simpleSingleTable = refs.length === 1 &&
+        !/\b(?:DISTINCT|GROUP\s+BY|UNION|EXCEPT|INTERSECT)\b/i.test(stripCommentsAndStrings(sql));
+    if (simpleSingleTable) {
+        const table = ir.tables.find((candidate) => candidate.name === refs[0]?.table);
+        const primary = columns.find((column) => table !== undefined &&
+            column.origin?.table === table.name &&
+            column.origin?.column === table.primaryKey);
+        if (primary !== undefined)
+            rowKey = [primary.langName];
+    }
+    return {
+        dependencies,
+        coverage,
+        ...(rowKey !== undefined ? { rowKey } : {}),
+    };
+}
 /** Synthesize the schema DDL from the IR (the reverse of the migration
  * parser): a `CREATE TABLE` per IR table with each column's declared SQLite
  * type + NOT NULL, so `prepare()` validates references and decltype resolves.
@@ -715,6 +843,7 @@ export function analyzeStatement(name, location, statementText, ir, db, naming =
                 type: source.column.type,
                 nullable: source.column.nullable,
                 fidelity: 'exact',
+                origin: { table: source.table, column: source.column.name },
             };
         }
         // Fallback: decltype affinity if present, else the expr-shape fallback.
@@ -758,6 +887,7 @@ export function analyzeStatement(name, location, statementText, ir, db, naming =
             throw new TypegenError(file, `-- param :${cp.name} names a parameter the query does not use`);
         }
     }
+    const reactive = inferReactiveMetadata(sql, refs, ir, params, columns);
     return {
         name,
         file,
@@ -767,6 +897,7 @@ export function analyzeStatement(name, location, statementText, ir, db, naming =
         params,
         columns,
         tables,
+        reactive,
     };
 }
 /**

package/dist/syql-ast.d.ts

@@ -0,0 +1,95 @@
+/** Stable, span-free semantic AST used by revision-1 conformance fixtures. */
+import { type SyqlToken } from './syql-lexer.js';
+import type { SyqlSyntaxFile, SyqlTemplate, SyqlValueType } from './syql-parser.js';
+export interface SyqlSemanticToken {
+    readonly kind: SyqlToken['kind'];
+    readonly text: string;
+}
+export interface SyqlSemanticType {
+    readonly base: SyqlValueType['base'];
+    readonly nullable: boolean;
+}
+export type SyqlSemanticTemplateNode = {
+    readonly kind: 'sql';
+    readonly tokens: readonly SyqlSemanticToken[];
+} | {
+    readonly kind: 'predicate-call';
+    readonly name: string;
+    readonly arguments: readonly string[];
+} | {
+    readonly kind: 'when';
+    readonly controls: readonly string[];
+    readonly body: readonly SyqlSemanticTemplateNode[];
+} | {
+    readonly kind: 'scope' | 'cover';
+    readonly bindings: readonly {
+        readonly qualifier: string;
+        readonly column: string;
+        readonly operator: 'equal' | 'in';
+        readonly values: readonly string[];
+    }[];
+};
+export interface SyqlSemanticTemplate {
+    readonly mode: SyqlTemplate['tree']['mode'];
+    readonly nodes: readonly SyqlSemanticTemplateNode[];
+}
+export type SyqlSemanticQueryParameter = {
+    readonly kind: 'value';
+    readonly name: string;
+    readonly optional: boolean;
+    readonly type?: SyqlSemanticType;
+} | {
+    readonly kind: 'switch';
+    readonly name: string;
+    readonly optional: true;
+} | {
+    readonly kind: 'group';
+    readonly name: string;
+    readonly optional: true;
+    readonly members: readonly {
+        readonly name: string;
+        readonly type?: SyqlSemanticType;
+    }[];
+};
+export type SyqlSemanticDeclaration = {
+    readonly kind: 'predicate';
+    readonly name: string;
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly type?: SyqlSemanticType;
+    }[];
+    readonly body: SyqlSemanticTemplate;
+} | {
+    readonly kind: 'query';
+    readonly name: string;
+    readonly parameters: readonly SyqlSemanticQueryParameter[];
+    readonly sql: SyqlSemanticTemplate;
+    readonly sort?: {
+        readonly control: string;
+        readonly defaultProfile: string;
+        readonly profiles: readonly {
+            readonly name: string;
+            readonly order: SyqlSemanticTemplate;
+        }[];
+    };
+    readonly page?: {
+        readonly control: string;
+        readonly defaultSize: number;
+        readonly maxSize: number;
+    };
+    readonly identity?: readonly string[];
+};
+export interface SyqlSemanticFile {
+    readonly kind: 'syql-file';
+    readonly revision: 1;
+    readonly imports: readonly {
+        readonly path: string;
+        readonly items: readonly {
+            readonly imported: string;
+            readonly local: string;
+        }[];
+    }[];
+    readonly declarations: readonly SyqlSemanticDeclaration[];
+}
+/** Return the stable syntax/semantic AST pinned by `spec/syql` fixtures. */
+export declare function toSyqlSemanticAst(file: SyqlSyntaxFile): SyqlSemanticFile;

package/dist/syql-ast.js

@@ -0,0 +1,138 @@
+/** Stable, span-free semantic AST used by revision-1 conformance fixtures. */
+import { isSyqlTrivia } from './syql-lexer.js';
+function semanticType(type) {
+    return type === undefined
+        ? undefined
+        : { base: type.base, nullable: type.nullable };
+}
+function semanticMember(member) {
+    const type = semanticType(member.type);
+    return { name: member.name, ...(type === undefined ? {} : { type }) };
+}
+function semanticParameter(parameter) {
+    if (parameter.kind === 'switch') {
+        return { kind: 'switch', name: parameter.name, optional: true };
+    }
+    if (parameter.kind === 'group') {
+        return {
+            kind: 'group',
+            name: parameter.name,
+            optional: true,
+            members: parameter.members.map(semanticMember),
+        };
+    }
+    const type = semanticType(parameter.type);
+    return {
+        kind: 'value',
+        name: parameter.name,
+        optional: parameter.optional,
+        ...(type === undefined ? {} : { type }),
+    };
+}
+function semanticRawTokens(tokens) {
+    return tokens
+        .filter((token) => !isSyqlTrivia(token))
+        .map((token) => ({ kind: token.kind, text: token.text }));
+}
+function semanticNode(node) {
+    if (node.kind === 'raw') {
+        const tokens = semanticRawTokens(node.tokens);
+        return tokens.length === 0 ? undefined : { kind: 'sql', tokens };
+    }
+    if (node.kind === 'predicate-call') {
+        return {
+            kind: 'predicate-call',
+            name: node.name,
+            arguments: node.arguments.map((argument) => argument.name),
+        };
+    }
+    if (node.kind === 'when') {
+        return {
+            kind: 'when',
+            controls: node.controls,
+            body: semanticNodes(node.body.nodes),
+        };
+    }
+    return {
+        kind: node.kind,
+        bindings: node.bindings.map((binding) => ({
+            qualifier: binding.column.qualifier,
+            column: binding.column.name,
+            operator: binding.operator,
+            values: binding.values.map((value) => value.name),
+        })),
+    };
+}
+function semanticNodes(nodes) {
+    return nodes.flatMap((node) => {
+        const semantic = semanticNode(node);
+        return semantic === undefined ? [] : [semantic];
+    });
+}
+function semanticTemplate(template) {
+    return {
+        mode: template.tree.mode,
+        nodes: semanticNodes(template.tree.nodes),
+    };
+}
+function semanticDeclaration(declaration) {
+    if (declaration.kind === 'predicate') {
+        return {
+            kind: 'predicate',
+            name: declaration.name,
+            parameters: declaration.parameters.map((parameter) => {
+                const type = semanticType(parameter.type);
+                return {
+                    name: parameter.name,
+                    ...(type === undefined ? {} : { type }),
+                };
+            }),
+            body: semanticTemplate(declaration.body),
+        };
+    }
+    return {
+        kind: 'query',
+        name: declaration.name,
+        parameters: declaration.parameters.map(semanticParameter),
+        sql: semanticTemplate(declaration.sql.body),
+        ...(declaration.sort === undefined
+            ? {}
+            : {
+                sort: {
+                    control: declaration.sort.control,
+                    defaultProfile: declaration.sort.defaultProfile,
+                    profiles: declaration.sort.profiles.map((profile) => ({
+                        name: profile.name,
+                        order: semanticTemplate(profile.order),
+                    })),
+                },
+            }),
+        ...(declaration.page === undefined
+            ? {}
+            : {
+                page: {
+                    control: declaration.page.control,
+                    defaultSize: declaration.page.defaultSize,
+                    maxSize: declaration.page.maxSize,
+                },
+            }),
+        ...(declaration.identity === undefined
+            ? {}
+            : { identity: declaration.identity.fields }),
+    };
+}
+/** Return the stable syntax/semantic AST pinned by `spec/syql` fixtures. */
+export function toSyqlSemanticAst(file) {
+    return {
+        kind: 'syql-file',
+        revision: 1,
+        imports: file.imports.map((declaration) => ({
+            path: declaration.path,
+            items: declaration.items.map((item) => ({
+                imported: item.imported,
+                local: item.local,
+            })),
+        })),
+        declarations: file.declarations.map(semanticDeclaration),
+    };
+}

package/dist/syql-lexer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Lossless lexer for the revision-1 SYQL frontend (`docs/SYQL.md` §2).
+ *
+ * The lexer owns the SQLite atomic-token boundary used by parsing, formatting,
+ * bind discovery, predicate expansion, and editor tooling. It never rewrites
+ * source text: concatenating every non-EOF token reproduces the input exactly.
+ */
+import { TypegenError } from './errors.js';
+export interface SyqlSourcePosition {
+    /** UTF-16 source offset, suitable for slicing the JavaScript source string. */
+    readonly offset: number;
+    /** One-based source line. */
+    readonly line: number;
+    /** One-based Unicode-scalar column. */
+    readonly column: number;
+}
+export interface SyqlSourceSpan {
+    readonly file: string;
+    readonly start: SyqlSourcePosition;
+    /** Exclusive end position. */
+    readonly end: SyqlSourcePosition;
+}
+export type SyqlTokenKind = 'whitespace' | 'line-comment' | 'block-comment' | 'identifier' | 'number' | 'string' | 'quoted-identifier' | 'import-path' | 'blob' | 'bind' | 'at-identifier' | 'punctuation' | 'operator' | 'eof';
+export interface SyqlToken {
+    readonly kind: SyqlTokenKind;
+    /** Exact source spelling. */
+    readonly text: string;
+    readonly span: SyqlSourceSpan;
+}
+export type SyqlLexErrorCode = 'SYQL1001_UNTERMINATED_STRING' | 'SYQL1002_UNTERMINATED_IDENTIFIER' | 'SYQL1003_UNTERMINATED_COMMENT' | 'SYQL1004_UNTERMINATED_IMPORT_PATH';
+/** A source-spanned, stable-code error shared by the lexer and parser. */
+export declare class SyqlFrontendError extends TypegenError {
+    readonly code: string;
+    readonly span: SyqlSourceSpan;
+    readonly sourceFile: string;
+    constructor(code: string, span: SyqlSourceSpan, message: string);
+}
+export declare function isSyqlTrivia(token: SyqlToken): boolean;
+/** Lex one complete `.syql` source file, including trivia and an EOF token. */
+export declare function lexSyqlSource(file: string, source: string): readonly SyqlToken[];