@syncular/typegen 0.5.1 → 0.7.0

package/dist/syql-template-parser.js

@@ -1,7 +1,6 @@
 /** 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,
@@ -17,12 +16,14 @@ class EmbeddedParser {
     #tokens;
     #span;
     #mode;
+    #rangeNames;
     #index = 0;
-    constructor(file, tokens, span, mode) {
+    constructor(file, tokens, span, mode, rangeNames) {
         this.#file = file;
         this.#tokens = tokens;
         this.#span = span;
         this.#mode = mode;
+        this.#rangeNames = rangeNames;
     }
     parse() {
         const nodes = [];
@@ -37,9 +38,6 @@ class EmbeddedParser {
                 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());
                 }
@@ -53,30 +51,40 @@ class EmbeddedParser {
         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';
         }
+        if (token.kind === 'identifier' && this.#isCallCandidate(token)) {
+            return 'predicate-call';
+        }
         return undefined;
     }
+    #isCallCandidate(token) {
+        let next = this.#peekAfter(token);
+        if (next?.token.text !== '(')
+            return false;
+        next = this.#peek(next.index + 1);
+        if (next?.token.text === ')')
+            return true;
+        for (;;) {
+            if (next?.token.kind !== 'bind')
+                return false;
+            next = this.#peek(next.index + 1);
+            if (next?.token.text === ')')
+                return true;
+            if (next?.token.text !== ',')
+                return false;
+            next = this.#peek(next.index + 1);
+            if (next?.token.text === ')')
+                return true;
+        }
+    }
     #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`);
-        }
+        const name = nameToken.text;
         this.#expectText('(', 'after predicate name');
         const args = [];
         if (this.#peek()?.token.text !== ')') {
@@ -106,19 +114,35 @@ class EmbeddedParser {
         }
         this.#expectText('(', 'after when');
         const controls = [];
+        const explicitPresenceFlags = [];
         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');
+            let explicitPresence = false;
+            let control;
+            const candidate = this.#peek()?.token;
+            if (candidate?.kind === 'identifier' &&
+                candidate.text === 'present' &&
+                this.#peekAfter(candidate)?.token.text === '(') {
+                this.#take();
+                this.#expectText('(', 'after present');
+                control = this.#expectIdentifier('present control');
+                this.#expectText(')', 'after present control');
+                explicitPresence = true;
+            }
+            else {
+                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);
+            explicitPresenceFlags.push(explicitPresence);
             controlSpans.push(control.span);
             if (this.#peek()?.token.text !== ',')
                 break;
@@ -127,107 +151,92 @@ class EmbeddedParser {
                 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);
+        let close;
+        let bodyTokens;
+        if (this.#peek()?.token.text === '{') {
+            const open = this.#expectText('{', 'to open when body');
+            const closeIndex = this.#matchingBraceIndex(open);
+            close = this.#tokens[closeIndex];
+            bodyTokens = this.#tokens.slice(this.#index, closeIndex);
+            this.#index = closeIndex + 1;
+        }
+        else {
+            const closeIndex = this.#singleWhenBodyEndIndex();
+            bodyTokens = this.#tokens.slice(this.#index, closeIndex);
+            const significant = bodyTokens.filter((token) => !isSyqlTrivia(token));
+            close = significant[significant.length - 1] ?? start;
+            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,
+            start: bodyTokens[0]?.span.start ?? close.span.start,
+            end: bodyTokens[bodyTokens.length - 1]?.span.end ?? close.span.start,
         };
-        const body = parseSyqlEmbeddedTemplate(this.#file, bodyTokens, bodySpan, 'condition');
-        this.#index = closeIndex + 1;
+        const body = parseSyqlEmbeddedTemplate(this.#file, bodyTokens, bodySpan, 'condition', this.#rangeNames);
         return {
             kind: 'when',
             controls,
+            explicitPresence: explicitPresenceFlags,
             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');
+    #singleWhenBodyEndIndex() {
+        let depth = 0;
+        let pendingBetween = false;
+        let rangeBetween = false;
+        const clauseEnders = new Set([
+            'group',
+            'having',
+            'order',
+            'limit',
+            'offset',
+            'window',
+            'union',
+            'intersect',
+            'except',
+        ]);
+        for (let cursor = this.#index; cursor < this.#tokens.length; cursor += 1) {
+            const token = this.#tokens[cursor];
+            if (isSyqlTrivia(token))
+                continue;
+            if (token.text === '(')
+                depth += 1;
+            else if (token.text === ')')
+                depth -= 1;
+            if (depth !== 0)
+                continue;
+            const lower = token.text.toLowerCase();
+            if (token.kind === 'identifier' && lower === 'between') {
+                const next = this.#peek(cursor + 1)?.token;
+                pendingBetween = true;
+                rangeBetween =
+                    next?.kind === 'bind' && this.#rangeNames.has(next.text.slice(1));
+                continue;
             }
-            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}`);
+            if (token.kind === 'identifier' && lower === 'and') {
+                if (pendingBetween && !rangeBetween) {
+                    pendingBetween = false;
+                    continue;
                 }
-                names.add(value.name);
-                values.push(value);
-                if (this.#peek()?.token.text !== ',')
-                    break;
-                this.#take();
-                if (this.#peek()?.token.text === ')')
-                    break;
+                return this.#leadingTriviaIndex(cursor);
             }
-            end = this.#expectText(')', 'to close scope in list');
+            if (token.text === '}' || clauseEnders.has(lower))
+                return this.#leadingTriviaIndex(cursor);
         }
-        return {
-            kind: 'scope-binding',
-            column,
-            operator: operator.text === '=' ? 'equal' : 'in',
-            values,
-            span: spanBetween(qualifier, end),
-        };
+        return this.#tokens.length;
+    }
+    #leadingTriviaIndex(index) {
+        let cursor = index;
+        while (cursor > this.#index &&
+            isSyqlTrivia(this.#tokens[cursor - 1]))
+            cursor -= 1;
+        return cursor;
     }
     #parseBindReference() {
         const token = this.#take();
@@ -241,6 +250,9 @@ class EmbeddedParser {
         return { kind: 'bind-reference', name, token, span: token.span };
     }
     #validateRawToken(token) {
+        if (token.kind === 'at-identifier') {
+            this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', token, `${token.text} uses removed directive/call syntax; use ordinary SQL predicates or a normal predicate call`);
+        }
         if (token.kind === 'bind') {
             if (this.#mode === 'order') {
                 this.#fail('SYQL3006_FORBIDDEN_TEMPLATE_NODE', token, 'binds are not allowed in sort profiles');
@@ -269,11 +281,6 @@ class EmbeddedParser {
             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) {
@@ -345,6 +352,6 @@ class EmbeddedParser {
     }
 }
 /** Parse embedded nodes from one already-delimited lossless template. */
-export function parseSyqlEmbeddedTemplate(file, tokens, span, mode) {
-    return new EmbeddedParser(file, tokens, span, mode).parse();
+export function parseSyqlEmbeddedTemplate(file, tokens, span, mode, rangeNames = new Set()) {
+    return new EmbeddedParser(file, tokens, span, mode, rangeNames).parse();
 }

package/dist/syql-validator.d.ts

@@ -0,0 +1,35 @@
+/** Schema-aware revision-1 SYQL validation (§§5, 8–13). */
+import type { IrDocument } from './ir.js';
+import { type AnalyzedQuery, type QueryDb, type QueryNamingOptions, type QueryReactiveMetadata } from './query.js';
+import type { SyqlValueType } from './syql-parser.js';
+import type { SyqlLogicalQuery, SyqlSemanticProgram } from './syql-semantics.js';
+export type SyqlValidationErrorCode = 'SYQL6001_INVALID_PLACEMENT' | 'SYQL6002_INVALID_SQL' | 'SYQL6003_NONDETERMINISTIC_SQL' | 'SYQL6004_TYPE_CONFLICT' | 'SYQL6005_INVALID_SYNC_QUERY' | 'SYQL6006_INVALID_SORT' | 'SYQL6007_INVALID_LIMIT' | 'SYQL6008_INVALID_IDENTITY';
+export interface SyqlValidatedSort {
+    readonly control: string;
+    readonly defaultProfile: string;
+    readonly profiles: readonly {
+        readonly name: string;
+        readonly sql: string;
+    }[];
+}
+export interface SyqlValidatedQuery {
+    readonly logical: SyqlLogicalQuery;
+    /** Reference realization: every conditional active, default controls. */
+    readonly referenceSql: string;
+    readonly analysis: AnalyzedQuery;
+    readonly bindTypes: ReadonlyMap<string, SyqlValueType>;
+    readonly reactive: QueryReactiveMetadata;
+    readonly identity?: readonly string[];
+    readonly sort?: SyqlValidatedSort;
+    readonly limit?: {
+        readonly control: string;
+        readonly defaultSize: number;
+        readonly maxSize: number;
+    };
+}
+export interface SyqlValidatedProgram {
+    readonly semantic: SyqlSemanticProgram;
+    readonly queries: readonly SyqlValidatedQuery[];
+}
+/** Validate a semantic SYQL program against schema IR and SQLite. */
+export declare function validateSyqlProgram(semantic: SyqlSemanticProgram, ir: IrDocument, db: QueryDb, naming?: QueryNamingOptions): SyqlValidatedProgram;