@syncular/typegen 0.15.12 → 0.15.14

package/dist/emit-queries.js

@@ -18,6 +18,27 @@ const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function propertyKey(name) {
     return IDENTIFIER_RE.test(name) ? name : quote(name);
 }
+function emitResultMapper(query, Row) {
+    const booleans = query.columns.filter((column) => column.type === 'boolean');
+    const lines = [
+        `/** Decode one storage-shaped result row for ${quote(query.name)}. */`,
+        `export function ${query.name}MapRow(row: Readonly<Record<string, unknown>>): ${Row} {`,
+    ];
+    if (booleans.length === 0) {
+        lines.push(`  return row as unknown as ${Row};`);
+    }
+    else {
+        lines.push('  return {', '    ...row,');
+        for (const column of booleans) {
+            const access = `row[${quote(column.langName)}]`;
+            const decoded = `decodeQueryBoolean(${access}, ${quote(query.name)}, ${quote(column.langName)})`;
+            lines.push(`    ${propertyKey(column.langName)}: ${column.nullable ? `${access} === null ? null : ${decoded}` : decoded},`);
+        }
+        lines.push(`  } as unknown as ${Row};`);
+    }
+    lines.push('}');
+    return lines;
+}
 /** A named-query param value is the SqlValue subset its type maps to. */
 const PARAM_TS_TYPE = TS_TYPE;
 const SYQL_PARAM_TS_TYPE = {
@@ -161,6 +182,7 @@ function emitSyqlQuery(query, hash) {
         lines.push(`  ${propertyKey(column.langName)}: ${TS_TYPE[column.type]}${column.nullable ? ' | null' : ''};`);
     }
     lines.push('}', '');
+    lines.push(...emitResultMapper(query, Row), '');
     for (const input of inputs) {
         if (input.kind === 'group') {
             lines.push(`export interface ${pascalCase(query.name)}${pascalCase(input.langName)} {`);
@@ -240,12 +262,12 @@ function emitSyqlQuery(query, hash) {
         : requiresParams
             ? `, params: ${Params}`
             : `, params?: ${Params}`;
-    lines.push(`/** Run the ${quote(query.name)} named query (SELECT-only). */`, `export async function ${query.name}(client: QueryClient${runnerParam}): Promise<${Row}[]> {`, `  const selected = ${query.name}Select(${hasParams ? 'params' : ''});`, '  const rows = await client.query(selected.sql, selected.bind);', `  return rows as unknown as ${Row}[];`, '}', '');
+    lines.push(`/** Run the ${quote(query.name)} named query (SELECT-only). */`, `export async function ${query.name}(client: QueryClient${runnerParam}): Promise<${Row}[]> {`, `  const selected = ${query.name}Select(${hasParams ? 'params' : ''});`, '  const rows = await client.query(selected.sql, selected.bind);', `  return rows.map((row) => ${query.name}MapRow(row as Readonly<Record<string, unknown>>));`, '}', '');
     const paramsType = hasParams ? Params : 'undefined';
     const defaultStatement = metadata.plan.statements.find((statement) => (statement.activationMask === undefined ||
         statement.activationMask === 0) &&
         (sort?.kind !== 'sort' || statement.sortProfile === sort.defaultProfile));
-    lines.push(`/** Revisioned reactive descriptor for \`useQuery(${query.name}Query${hasParams ? ', params' : ''})\`. */`, `export const ${query.name}Query: NamedQuery<${Row}, ${paramsType}> = {`, `  id: ${quote(`${hash}/${query.name}`)},`, `  hasParams: ${hasParams},`, `  sql: ${quote(defaultStatement?.positionalSql ?? query.positionalSql)},`);
+    lines.push(`/** Revisioned reactive descriptor for \`useQuery(${query.name}Query${hasParams ? ', params' : ''})\`. */`, `export const ${query.name}Query: NamedQuery<${Row}, ${paramsType}> = {`, `  id: ${quote(`${hash}/${query.name}`)},`, `  hasParams: ${hasParams},`, `  sql: ${quote(defaultStatement?.positionalSql ?? query.positionalSql)},`, `  mapRow: ${query.name}MapRow,`);
     if (hasParams) {
         lines.push(`  sqlFor: (params: ${Params}) => ${query.name}Select(params).sql,`);
     }
@@ -297,6 +319,8 @@ function emitQuery(query, hash) {
     }
     lines.push('}');
     lines.push('');
+    lines.push(...emitResultMapper(query, Row));
+    lines.push('');
     const hasParams = query.params.length > 0;
     if (hasParams) {
         lines.push(`/** Named parameters for ${quote(query.name)}. */`);
@@ -324,7 +348,7 @@ function emitQuery(query, hash) {
     else {
         lines.push(`  const rows = await client.query(${sqlConst});`);
     }
-    lines.push(`  return rows as unknown as ${Row}[];`);
+    lines.push(`  return rows.map((row) => ${query.name}MapRow(row as Readonly<Record<string, unknown>>));`);
     lines.push('}');
     lines.push('');
     lines.push(`/** Revisioned reactive descriptor for \`useQuery(${query.name}Query${hasParams ? ', params' : ''})\`. */`);
@@ -333,6 +357,7 @@ function emitQuery(query, hash) {
     lines.push(`  id: ${quote(`${hash}/${query.name}`)},`);
     lines.push(`  hasParams: ${hasParams},`);
     lines.push(`  sql: ${sqlConst},`);
+    lines.push(`  mapRow: ${query.name}MapRow,`);
     lines.push(`  tables: ${query.name}Tables,`);
     const reactiveUsesParams = query.reactive.dependencies.some((dependency) => dependency.scopes.some((scope) => scope.params.length > 0));
     lines.push(`  dependencies: (${reactiveUsesParams ? 'params' : ''}) => [`);
@@ -398,6 +423,24 @@ export function emitQueriesModule(queries, hash, irVersion) {
             '}',
         ].join('\n'));
     }
+    if (queries.some((query) => query.columns.some((column) => column.type === 'boolean'))) {
+        parts.push([
+            '/** A generated named-query row did not match its analyzed result type. */',
+            'export class QueryResultDecodeError extends TypeError {',
+            "  readonly name = 'QueryResultDecodeError';",
+            '  constructor(readonly query: string, readonly column: string) {',
+            "    super(query + ': result column ' + column + ' is not a SQLite boolean');",
+            '  }',
+            '}',
+            '',
+            '/** Lift a SQLite boolean: preserve booleans, map 0 to false and finite non-zero numbers to true. */',
+            'function decodeQueryBoolean(value: unknown, query: string, column: string): boolean {',
+            "  if (typeof value === 'boolean') return value;",
+            "  if (typeof value === 'number' && Number.isFinite(value)) return value !== 0;",
+            '  throw new QueryResultDecodeError(query, column);',
+            '}',
+        ].join('\n'));
+    }
     parts.push([
         "/** A bindable SQL param/row value (the wrapper's SqlValue subset). */",
         'export type QueryValue =',
@@ -427,6 +470,7 @@ export function emitQueriesModule(queries, hash, irVersion) {
         '  readonly id: string;',
         '  readonly hasParams: boolean;',
         '  readonly sql: string;',
+        '  readonly mapRow: (row: Readonly<Record<string, unknown>>) => Row;',
         '  readonly tables: readonly string[];',
         '  readonly bind: (params: Params) => readonly QueryValue[];',
         '  readonly sqlFor?: (params: Params) => string;',

package/dist/generate.js

@@ -11,6 +11,7 @@ import { emitKotlinModule } from './emit-kotlin.js';
 import { emitQueriesModule } from './emit-queries.js';
 import { emitQueriesDartModule } from './emit-queries-dart.js';
 import { emitQueriesKotlinModule } from './emit-queries-kotlin.js';
+import { emitQueriesRustModule } from './emit-queries-rust.js';
 import { emitQueriesSwiftModule } from './emit-queries-swift.js';
 import { emitSwiftModule } from './emit-swift.js';
 import { TypegenError } from './errors.js';
@@ -347,6 +348,8 @@ export function generate(manifestDir) {
         targets.push('kotlin');
     if (manifest.output.dart !== undefined)
         targets.push('dart');
+    if (manifest.output.rust !== undefined)
+        targets.push('rust');
     const naming = {
         naming: manifest.naming,
         targets,
@@ -365,7 +368,7 @@ export function generate(manifestDir) {
         { path: modulePath, content: module },
     ];
     // Opt-in native emitters — each present only when the manifest requests it.
-    const { queryIr: queryIrPath, queries: tsQueriesPath, swift, kotlin, dart, } = manifest.output;
+    const { queryIr: queryIrPath, queries: tsQueriesPath, swift, kotlin, dart, rust, } = manifest.output;
     // Named queries: analyzed once (SELECT-only, typed against the IR via
     // SQLite), then emitted per-language into its OWN file so schema-only
     // consumers never churn. Only analyzed when SOME query output is requested.
@@ -373,7 +376,8 @@ export function generate(manifestDir) {
         tsQueriesPath !== undefined ||
         swift?.queriesPath !== undefined ||
         kotlin?.queriesPath !== undefined ||
-        dart?.queriesPath !== undefined;
+        dart?.queriesPath !== undefined ||
+        rust?.queriesPath !== undefined;
     const analyzedQueries = wantsQueries
         ? analyzeQueries(ir, loadQueries(resolve(manifestDir, manifest.queries)), naming, resolve(manifestDir, manifest.queries))
         : [];
@@ -430,6 +434,12 @@ export function generate(manifestDir) {
             });
         }
     }
+    if (rust !== undefined) {
+        outputs.push({
+            path: resolve(manifestDir, rust.queriesPath),
+            content: emitQueriesRustModule(analyzedQueries, queryHash, ir.irVersion, rust.clientCrate),
+        });
+    }
     return {
         ir,
         irJson,

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from './emit-kotlin.js';
 export * from './emit-queries.js';
 export * from './emit-queries-dart.js';
 export * from './emit-queries-kotlin.js';
+export * from './emit-queries-rust.js';
 export * from './emit-queries-swift.js';
 export * from './emit-swift.js';
 export * from './errors.js';

package/dist/index.js

@@ -9,6 +9,7 @@ export * from './emit-kotlin.js';
 export * from './emit-queries.js';
 export * from './emit-queries-dart.js';
 export * from './emit-queries-kotlin.js';
+export * from './emit-queries-rust.js';
 export * from './emit-queries-swift.js';
 export * from './emit-swift.js';
 export * from './errors.js';

package/dist/lsp.js

@@ -186,6 +186,8 @@ export class SyqlLanguageServer {
                 targets.push('kotlin');
             if (manifest.output.dart !== undefined)
                 targets.push('dart');
+            if (manifest.output.rust !== undefined)
+                targets.push('rust');
             const lookup = {
                 kind: 'ready',
                 context: {

package/dist/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { NamingMode } from './naming.js';
+import { type NamingMode } from './naming.js';
 /** §7/§8 `.syql` conditional-lowering backend selection. */
 export type ManifestQueryBackend = 'neutralize' | 'variants' | 'auto';
 export declare const MANIFEST_FILENAME = "syncular.json";
@@ -53,6 +53,13 @@ export interface DartOutput {
     /** Opt-in named-queries output path (a sibling `.dart` file). */
     readonly queriesPath?: string;
 }
+/** Rust named-query output. Rust consumes neutral schema IR at runtime, so
+ * revision 1 has no separate generated schema source path. */
+export interface RustOutput {
+    readonly queriesPath: string;
+    /** Rust module identifier for the `syncular-client` Cargo dependency. */
+    readonly clientCrate: string;
+}
 export interface ManifestOutput {
     readonly ir: string;
     readonly module: string;
@@ -66,6 +73,7 @@ export interface ManifestOutput {
     readonly swift?: SwiftOutput;
     readonly kotlin?: KotlinOutput;
     readonly dart?: DartOutput;
+    readonly rust?: RustOutput;
 }
 export interface Manifest {
     readonly manifestVersion: 1;

package/dist/manifest.js

@@ -28,19 +28,21 @@
  *   placeholders (partial templates are unsupported).
  * - `output.ir` / `output.module` are the always-emitted TS defaults;
  *   `output.queryIr` opts into the deterministic analyzed-query document.
- *   `output.swift` / `output.kotlin` / `output.dart` are OPT-IN native
+ *   `output.swift` / `output.kotlin` / `output.dart` are OPT-IN native schema
  *   emitters — a bare string is the output path; an object carries
  *   language-appropriate options (Kotlin `package`/`objectName`, Swift
  *   `enumName`; Dart takes `path` only). This is additive within the `output`
  *   object (the same forward-extension shape `output.ir`/`output.module`
  *   already use); no `manifestVersion` bump — new *recognized* keys, not
  *   tolerated-unknown ones. Absent → that language is not generated (TS
- *   stays the default).
+ *   stays the default). `output.rust.queriesPath` opts into Rust named-query
+ *   source over the neutral schema IR consumed by `syncular-client`.
  * - Unknown keys are hard errors everywhere (fail loud; growth happens by
  *   bumping `manifestVersion`), except inside `extensions`, the reserved
  *   WP-49 passthrough slot copied verbatim into the IR.
  */
 import { TypegenError } from './errors.js';
+import { isRustKeyword } from './naming.js';
 export const MANIFEST_FILENAME = 'syncular.json';
 const SOURCE = MANIFEST_FILENAME;
 function fail(message) {
@@ -137,6 +139,21 @@ function parseDartOutput(value) {
             : {}),
     };
 }
+const RUST_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseRustOutput(value) {
+    const obj = asObject(value, 'output.rust');
+    rejectUnknownKeys(obj, ['queriesPath', 'clientCrate'], 'output.rust');
+    const clientCrate = obj.clientCrate === undefined
+        ? 'syncular_client'
+        : asString(obj.clientCrate, 'output.rust.clientCrate');
+    if (!RUST_IDENTIFIER_RE.test(clientCrate) || isRustKeyword(clientCrate)) {
+        fail(`output.rust.clientCrate must be one Rust identifier, got ${JSON.stringify(clientCrate)}`);
+    }
+    return {
+        queriesPath: asString(obj.queriesPath, 'output.rust.queriesPath'),
+        clientCrate,
+    };
+}
 function parseTable(value, index) {
     const context = `tables[${index}]`;
     const obj = asObject(value, context);
@@ -248,9 +265,10 @@ export function parseManifest(raw) {
     let swift;
     let kotlin;
     let dart;
+    let rust;
     if (obj.output !== undefined) {
         const output = asObject(obj.output, 'output');
-        rejectUnknownKeys(output, ['ir', 'module', 'queryIr', 'queries', 'swift', 'kotlin', 'dart'], 'output');
+        rejectUnknownKeys(output, ['ir', 'module', 'queryIr', 'queries', 'swift', 'kotlin', 'dart', 'rust'], 'output');
         if (output.ir !== undefined)
             ir = asString(output.ir, 'output.ir');
         if (output.module !== undefined) {
@@ -268,6 +286,8 @@ export function parseManifest(raw) {
             kotlin = parseKotlinOutput(output.kotlin);
         if (output.dart !== undefined)
             dart = parseDartOutput(output.dart);
+        if (output.rust !== undefined)
+            rust = parseRustOutput(output.rust);
     }
     // Build `output` with only the keys that are set — `exactOptionalPropertyTypes`
     // forbids explicit `undefined` on optional properties.
@@ -279,6 +299,7 @@ export function parseManifest(raw) {
         ...(swift !== undefined ? { swift } : {}),
         ...(kotlin !== undefined ? { kotlin } : {}),
         ...(dart !== undefined ? { dart } : {}),
+        ...(rust !== undefined ? { rust } : {}),
     };
     if (!Array.isArray(obj.schemaVersions) || obj.schemaVersions.length === 0) {
         fail('schemaVersions must be a non-empty array (§1.5 version history)');

package/dist/naming.d.ts

@@ -6,7 +6,17 @@ export declare function snakeToCamel(name: string): string;
 /** The emitter targets whose keyword sets we police. `ts` is included for
  * completeness (its emitters can quote any property, so its list is the
  * small set that breaks generated FUNCTION/const identifiers). */
-export type NamingTarget = 'ts' | 'swift' | 'kotlin' | 'dart';
+export type NamingTarget = 'ts' | 'swift' | 'kotlin' | 'dart' | 'rust';
+export declare function isRustKeyword(name: string): boolean;
+/** Pinned Rust identifier conversion from RFC 0006. */
+export declare function rustSnakeCase(name: string): string;
+export declare function rustPascalCase(name: string): string;
+export interface RustNameMapping {
+    readonly langName: string;
+    readonly rustName: string;
+}
+/** Validate and map QueryIR runtime names to emitted Rust identifiers. */
+export declare function buildRustNamingMap(langNames: readonly string[], context: string, scope: string): RustNameMapping[];
 /** One naming-map entry: the SQL-truth name and its language-facing name. */
 export interface NameMapping {
     readonly sqlName: string;

package/dist/naming.js

@@ -202,7 +202,130 @@ const TARGET_KEYWORDS = {
         'while',
         'with',
     ]),
+    rust: new Set([
+        'abstract',
+        'as',
+        'async',
+        'await',
+        'become',
+        'box',
+        'break',
+        'const',
+        'continue',
+        'crate',
+        'do',
+        'dyn',
+        'else',
+        'enum',
+        'extern',
+        'false',
+        'final',
+        'fn',
+        'for',
+        'gen',
+        'if',
+        'impl',
+        'in',
+        'let',
+        'loop',
+        'macro',
+        'match',
+        'mod',
+        'move',
+        'mut',
+        'override',
+        'priv',
+        'pub',
+        'ref',
+        'return',
+        'self',
+        'static',
+        'struct',
+        'super',
+        'trait',
+        'true',
+        'try',
+        'type',
+        'typeof',
+        'unsafe',
+        'unsized',
+        'use',
+        'virtual',
+        'where',
+        'while',
+        'yield',
+    ]),
 };
+export function isRustKeyword(name) {
+    return TARGET_KEYWORDS.rust.has(name);
+}
+/** Pinned Rust identifier conversion from RFC 0006. */
+export function rustSnakeCase(name) {
+    if (!/^_*[A-Za-z][A-Za-z0-9_]*$/.test(name))
+        return name;
+    const lead = /^_*/.exec(name)?.[0] ?? '';
+    const withoutLead = name.slice(lead.length);
+    const trail = /_*$/.exec(withoutLead)?.[0] ?? '';
+    const middle = withoutLead.slice(0, withoutLead.length - trail.length);
+    const out = [];
+    for (let index = 0; index < middle.length; index++) {
+        const char = middle[index];
+        if (char === '_') {
+            if (out.length > 0 && out[out.length - 1] !== '_')
+                out.push('_');
+            continue;
+        }
+        const previous = index > 0 ? middle[index - 1] : undefined;
+        const next = index + 1 < middle.length ? middle[index + 1] : undefined;
+        const uppercase = char >= 'A' && char <= 'Z';
+        const previousLowerOrDigit = previous !== undefined && /[a-z0-9]/.test(previous);
+        const acronymBoundary = uppercase &&
+            previous !== undefined &&
+            /[A-Z]/.test(previous) &&
+            next !== undefined &&
+            /[a-z]/.test(next);
+        if (uppercase &&
+            (previousLowerOrDigit || acronymBoundary) &&
+            out.length > 0 &&
+            out[out.length - 1] !== '_') {
+            out.push('_');
+        }
+        out.push(char.toLowerCase());
+    }
+    return lead + out.join('') + trail;
+}
+export function rustPascalCase(name) {
+    const snake = rustSnakeCase(name);
+    const lead = /^_*/.exec(snake)?.[0] ?? '';
+    const bare = snake.slice(lead.length).replace(/_*$/, '');
+    const suffix = snake.slice(lead.length + bare.length);
+    return (lead +
+        bare
+            .split('_')
+            .filter((part) => part.length > 0)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('') +
+        suffix);
+}
+/** Validate and map QueryIR runtime names to emitted Rust identifiers. */
+export function buildRustNamingMap(langNames, context, scope) {
+    const seen = new Map();
+    return langNames.map((langName) => {
+        const rustName = rustSnakeCase(langName);
+        if (!/^_*[a-z][a-z0-9_]*$/.test(rustName)) {
+            throw new TypegenError(context, `${scope}: ${JSON.stringify(langName)} cannot be emitted as a Rust identifier — alias it in SQL (AS)`);
+        }
+        if (TARGET_KEYWORDS.rust.has(rustName)) {
+            throw new TypegenError(context, `${scope}: ${JSON.stringify(langName)} maps to ${JSON.stringify(rustName)}, a reserved word on the rust target — alias it in SQL (AS)`);
+        }
+        const clash = seen.get(rustName);
+        if (clash !== undefined && clash !== langName) {
+            throw new TypegenError(context, `${scope}: ${JSON.stringify(clash)} and ${JSON.stringify(langName)} both map to ${JSON.stringify(rustName)} on the rust target — alias one in SQL (AS)`);
+        }
+        seen.set(rustName, langName);
+        return { langName, rustName };
+    });
+}
 /**
  * Map a set of SQL names to language names under `mode`, enforcing the §12
  * hard errors within the scope (one table's columns / one query's projection
@@ -223,8 +346,9 @@ export function buildNamingMap(sqlNames, mode, context, scope, targets) {
             throw new TypegenError(context, `${scope}: ${JSON.stringify(clash)} and ${JSON.stringify(sqlName)} both map to ${JSON.stringify(langName)} under camelCase naming — rename one, alias it in SQL (AS), or set "naming": "preserve" in syncular.json`);
         }
         for (const target of targets) {
-            if (TARGET_KEYWORDS[target].has(langName)) {
-                throw new TypegenError(context, `${scope}: ${JSON.stringify(sqlName)} maps to ${JSON.stringify(langName)}, a reserved word on the ${target} target — rename it, alias it in SQL (AS), or set "naming": "preserve" in syncular.json`);
+            const targetName = target === 'rust' ? rustSnakeCase(langName) : langName;
+            if (TARGET_KEYWORDS[target].has(targetName)) {
+                throw new TypegenError(context, `${scope}: ${JSON.stringify(sqlName)} maps to ${JSON.stringify(targetName)}, a reserved word on the ${target} target — rename it, alias it in SQL (AS), or set "naming": "preserve" in syncular.json`);
             }
             if (target === 'dart' && langName.startsWith('_')) {
                 throw new TypegenError(context, `${scope}: ${JSON.stringify(sqlName)} maps to ${JSON.stringify(langName)} — a leading underscore is library-private on the dart target. Alias it in SQL (AS) or set "naming": "preserve" in syncular.json`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.15.12",
+  "version": "0.15.14",
   "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.15.12",
-    "@syncular/server": "0.15.12"
+    "@syncular/core": "0.15.14",
+    "@syncular/server": "0.15.14"
   }
 }