@syncular/typegen 0.3.1 → 0.4.0

package/dist/emit-dart.js

@@ -172,26 +172,35 @@ export function emitDartModule(ir, hash) {
     for (const line of schemaValue)
         schemaLines.push(line);
     parts.push(schemaLines.join('\n'));
-    // Shared row-decode helpers.
-    parts.push([
-        '/// Lift a SQLite boolean: a real bool, or 0/1 as a number.',
-        'bool? _rowBool(Object? value) {',
-        '  if (value is bool) return value;',
-        '  if (value is num) return value != 0;',
-        '  return null;',
-        '}',
-        '',
-        "/// Decode the core's {'\\$bytes': '<hex>'} marshaling (bytes as hex).",
-        'List<int>? _rowBytes(Object? value) {',
-        '  if (value is! Map) return null;',
-        "  final hex = value[r'$bytes'];",
-        '  if (hex is! String || hex.length % 2 != 0) return null;',
-        '  return [',
-        '    for (var i = 0; i < hex.length; i += 2)',
-        '      int.parse(hex.substring(i, i + 2), radix: 16),',
-        '  ];',
-        '}',
-    ].join('\n'));
+    // Shared row-decode helpers — emitted only when a column type references
+    // them. An unused private helper is an ANALYZER diagnostic (unused_element),
+    // which the `type=lint` ignore above does not cover, so a schema without
+    // boolean or bytes/crdt columns would fail a fatal-warnings `dart analyze`.
+    const columnTypes = new Set(ir.tables.flatMap((table) => table.columns.map((column) => column.type)));
+    if (columnTypes.has('boolean')) {
+        parts.push([
+            '/// Lift a SQLite boolean: a real bool, or 0/1 as a number.',
+            'bool? _rowBool(Object? value) {',
+            '  if (value is bool) return value;',
+            '  if (value is num) return value != 0;',
+            '  return null;',
+            '}',
+        ].join('\n'));
+    }
+    if (columnTypes.has('bytes') || columnTypes.has('crdt')) {
+        parts.push([
+            "/// Decode the core's {'\\$bytes': '<hex>'} marshaling (bytes as hex).",
+            'List<int>? _rowBytes(Object? value) {',
+            '  if (value is! Map) return null;',
+            "  final hex = value[r'$bytes'];",
+            '  if (hex is! String || hex.length % 2 != 0) return null;',
+            '  return [',
+            '    for (var i = 0; i < hex.length; i += 2)',
+            '      int.parse(hex.substring(i, i + 2), radix: 16),',
+            '  ];',
+            '}',
+        ].join('\n'));
+    }
     for (const table of ir.tables) {
         parts.push(emitClass(table).join('\n'));
     }

package/dist/emit-kotlin.js

@@ -177,24 +177,34 @@ export function emitKotlinModule(ir, hash, packageName, objectName) {
     schemaLines.push('    }');
     schemaLines.push('}');
     parts.push(schemaLines.join('\n'));
-    // Shared row-decode helpers.
-    parts.push([
-        '/** Lift a SQLite boolean: a real JSON bool, or 0/1 as a number. */',
-        'private fun rowBool(value: JsonValue?): Boolean? {',
-        '    value?.bool?.let { return it }',
-        '    value?.number?.let { return it != 0.0 }',
-        '    return null',
-        '}',
-        '',
-        '/** Decode the core\'s `{"$bytes":"<hex>"}` marshaling into a ByteArray. */',
-        'private fun rowBytes(value: JsonValue?): ByteArray? {',
-        '    val hex = value?.get("\\$bytes")?.string ?: return null',
-        '    if (hex.length % 2 != 0) return null',
-        '    return ByteArray(hex.length / 2) { i ->',
-        '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
-        '    }',
-        '}',
-    ].join('\n'));
+    // Shared row-decode helpers — emitted only when a column type references
+    // them (the Dart emitter's rule): an unused private fun is dead code in a
+    // generated file and an "is never used" inspection in every IDE. The
+    // query emitter is unaffected — it declares its own queryRowBool/
+    // queryRowBytes copies under distinct names.
+    const columnTypes = new Set(ir.tables.flatMap((table) => table.columns.map((column) => column.type)));
+    if (columnTypes.has('boolean')) {
+        parts.push([
+            '/** Lift a SQLite boolean: a real JSON bool, or 0/1 as a number. */',
+            'private fun rowBool(value: JsonValue?): Boolean? {',
+            '    value?.bool?.let { return it }',
+            '    value?.number?.let { return it != 0.0 }',
+            '    return null',
+            '}',
+        ].join('\n'));
+    }
+    if (columnTypes.has('bytes') || columnTypes.has('crdt')) {
+        parts.push([
+            '/** Decode the core\'s `{"$bytes":"<hex>"}` marshaling into a ByteArray. */',
+            'private fun rowBytes(value: JsonValue?): ByteArray? {',
+            '    val hex = value?.get("\\$bytes")?.string ?: return null',
+            '    if (hex.length % 2 != 0) return null',
+            '    return ByteArray(hex.length / 2) { i ->',
+            '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
+            '    }',
+            '}',
+        ].join('\n'));
+    }
     for (const table of ir.tables) {
         parts.push(emitDataClass(table).join('\n'));
     }

package/dist/emit-queries-dart.js

@@ -77,9 +77,9 @@ function emitOrderByEnum(query) {
     const lines = [];
     lines.push(`/// §6 orderBy allowlist for ${query.name} — checked at generate time.`);
     lines.push(`enum ${typeName(query.name)}OrderBy {`);
-    lines.push(query.orderBy.allowed
+    lines.push(`${query.orderBy.allowed
         .map((col) => `  ${camelCase(col.langName)}(${quote(col.name)})`)
-        .join(',\n') + ';');
+        .join(',\n')};`);
     lines.push('');
     lines.push(`  const ${typeName(query.name)}OrderBy(this.column);`);
     lines.push('  final String column;');

package/dist/emit-queries-kotlin.js

@@ -9,13 +9,6 @@ const KOTLIN_TYPE = {
     blob_ref: 'String',
     crdt: 'ByteArray',
 };
-function pascalCase(name) {
-    return name
-        .split(/[_-]+/)
-        .filter((p) => p.length > 0)
-        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-        .join('');
-}
 /** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name) {
     return snakeToCamel(name);
@@ -85,9 +78,9 @@ function emitOrderByEnum(query) {
     const lines = [];
     lines.push(`/** §6 orderBy allowlist for ${query.name} — checked at generate time. */`);
     lines.push(`enum class ${typeName(query.name)}OrderBy(val column: String) {`);
-    lines.push(query.orderBy.allowed
+    lines.push(`${query.orderBy.allowed
         .map((col) => `    ${camelCase(col.langName)}(${quote(col.name)})`)
-        .join(',\n') + ';');
+        .join(',\n')};`);
     lines.push('}');
     return lines;
 }

package/dist/emit-queries-swift.js

@@ -9,13 +9,6 @@ const SWIFT_TYPE = {
     blob_ref: 'String',
     crdt: '[UInt8]',
 };
-function pascalCase(name) {
-    return name
-        .split(/[_-]+/)
-        .filter((p) => p.length > 0)
-        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-        .join('');
-}
 /** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name) {
     return snakeToCamel(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.3.1",
+  "version": "0.4.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.2.1",
-    "@syncular/server": "0.2.1"
+    "@syncular/core": "0.3.1",
+    "@syncular/server": "0.3.1"
   }
 }

package/src/emit-dart.ts

@@ -212,28 +212,41 @@ export function emitDartModule(ir: IrDocument, hash: string): string {
   for (const line of schemaValue) schemaLines.push(line);
   parts.push(schemaLines.join('\n'));
 
-  // Shared row-decode helpers.
-  parts.push(
-    [
-      '/// Lift a SQLite boolean: a real bool, or 0/1 as a number.',
-      'bool? _rowBool(Object? value) {',
-      '  if (value is bool) return value;',
-      '  if (value is num) return value != 0;',
-      '  return null;',
-      '}',
-      '',
-      "/// Decode the core's {'\\$bytes': '<hex>'} marshaling (bytes as hex).",
-      'List<int>? _rowBytes(Object? value) {',
-      '  if (value is! Map) return null;',
-      "  final hex = value[r'$bytes'];",
-      '  if (hex is! String || hex.length % 2 != 0) return null;',
-      '  return [',
-      '    for (var i = 0; i < hex.length; i += 2)',
-      '      int.parse(hex.substring(i, i + 2), radix: 16),',
-      '  ];',
-      '}',
-    ].join('\n'),
+  // Shared row-decode helpers — emitted only when a column type references
+  // them. An unused private helper is an ANALYZER diagnostic (unused_element),
+  // which the `type=lint` ignore above does not cover, so a schema without
+  // boolean or bytes/crdt columns would fail a fatal-warnings `dart analyze`.
+  const columnTypes = new Set(
+    ir.tables.flatMap((table) => table.columns.map((column) => column.type)),
   );
+  if (columnTypes.has('boolean')) {
+    parts.push(
+      [
+        '/// Lift a SQLite boolean: a real bool, or 0/1 as a number.',
+        'bool? _rowBool(Object? value) {',
+        '  if (value is bool) return value;',
+        '  if (value is num) return value != 0;',
+        '  return null;',
+        '}',
+      ].join('\n'),
+    );
+  }
+  if (columnTypes.has('bytes') || columnTypes.has('crdt')) {
+    parts.push(
+      [
+        "/// Decode the core's {'\\$bytes': '<hex>'} marshaling (bytes as hex).",
+        'List<int>? _rowBytes(Object? value) {',
+        '  if (value is! Map) return null;',
+        "  final hex = value[r'$bytes'];",
+        '  if (hex is! String || hex.length % 2 != 0) return null;',
+        '  return [',
+        '    for (var i = 0; i < hex.length; i += 2)',
+        '      int.parse(hex.substring(i, i + 2), radix: 16),',
+        '  ];',
+        '}',
+      ].join('\n'),
+    );
+  }
 
   for (const table of ir.tables) {
     parts.push(emitClass(table).join('\n'));

package/src/emit-kotlin.ts

@@ -229,26 +229,40 @@ export function emitKotlinModule(
   schemaLines.push('}');
   parts.push(schemaLines.join('\n'));
 
-  // Shared row-decode helpers.
-  parts.push(
-    [
-      '/** Lift a SQLite boolean: a real JSON bool, or 0/1 as a number. */',
-      'private fun rowBool(value: JsonValue?): Boolean? {',
-      '    value?.bool?.let { return it }',
-      '    value?.number?.let { return it != 0.0 }',
-      '    return null',
-      '}',
-      '',
-      '/** Decode the core\'s `{"$bytes":"<hex>"}` marshaling into a ByteArray. */',
-      'private fun rowBytes(value: JsonValue?): ByteArray? {',
-      '    val hex = value?.get("\\$bytes")?.string ?: return null',
-      '    if (hex.length % 2 != 0) return null',
-      '    return ByteArray(hex.length / 2) { i ->',
-      '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
-      '    }',
-      '}',
-    ].join('\n'),
+  // Shared row-decode helpers — emitted only when a column type references
+  // them (the Dart emitter's rule): an unused private fun is dead code in a
+  // generated file and an "is never used" inspection in every IDE. The
+  // query emitter is unaffected — it declares its own queryRowBool/
+  // queryRowBytes copies under distinct names.
+  const columnTypes = new Set(
+    ir.tables.flatMap((table) => table.columns.map((column) => column.type)),
   );
+  if (columnTypes.has('boolean')) {
+    parts.push(
+      [
+        '/** Lift a SQLite boolean: a real JSON bool, or 0/1 as a number. */',
+        'private fun rowBool(value: JsonValue?): Boolean? {',
+        '    value?.bool?.let { return it }',
+        '    value?.number?.let { return it != 0.0 }',
+        '    return null',
+        '}',
+      ].join('\n'),
+    );
+  }
+  if (columnTypes.has('bytes') || columnTypes.has('crdt')) {
+    parts.push(
+      [
+        '/** Decode the core\'s `{"$bytes":"<hex>"}` marshaling into a ByteArray. */',
+        'private fun rowBytes(value: JsonValue?): ByteArray? {',
+        '    val hex = value?.get("\\$bytes")?.string ?: return null',
+        '    if (hex.length % 2 != 0) return null',
+        '    return ByteArray(hex.length / 2) { i ->',
+        '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
+        '    }',
+        '}',
+      ].join('\n'),
+    );
+  }
 
   for (const table of ir.tables) {
     parts.push(emitDataClass(table).join('\n'));

package/src/emit-queries-dart.ts

@@ -102,9 +102,9 @@ function emitOrderByEnum(query: AnalyzedQuery): string[] {
   );
   lines.push(`enum ${typeName(query.name)}OrderBy {`);
   lines.push(
-    query.orderBy.allowed
+    `${query.orderBy.allowed
       .map((col) => `  ${camelCase(col.langName)}(${quote(col.name)})`)
-      .join(',\n') + ';',
+      .join(',\n')};`,
   );
   lines.push('');
   lines.push(`  const ${typeName(query.name)}OrderBy(this.column);`);

package/src/emit-queries-kotlin.ts

@@ -5,10 +5,11 @@
  * `q(client, …): List<QRow>` runner + `qTables` constant. The runner binds
  * named params positionally into the wrapper's `query(sql, params)`.
  *
- * Reuses the schema file's `rowBool`/`rowBytes` helpers (they are top-level
- * private in the schema module; queries live in the same package so re-declare
- * package-private copies here to stay self-contained — the query file is a
- * separate output). Header carries the IR hash for byte-exact `--check`.
+ * Self-contained: declares its own `queryRowBool`/`queryRowBytes` copies of
+ * the schema file's row-decode helpers (distinct names — both files are
+ * file-`private` in the same package, and the schema file only emits its
+ * helpers when a column type needs them). Header carries the IR hash for
+ * byte-exact `--check`.
  */
 import type { IrColumnType } from './ir';
 import { snakeToCamel } from './naming';
@@ -25,14 +26,6 @@ const KOTLIN_TYPE: Readonly<Record<IrColumnType, string>> = {
   crdt: 'ByteArray',
 };
 
-function pascalCase(name: string): string {
-  return name
-    .split(/[_-]+/)
-    .filter((p) => p.length > 0)
-    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-    .join('');
-}
-
 /** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name: string): string {
   return snakeToCamel(name);
@@ -113,9 +106,9 @@ function emitOrderByEnum(query: AnalyzedQuery): string[] {
   );
   lines.push(`enum class ${typeName(query.name)}OrderBy(val column: String) {`);
   lines.push(
-    query.orderBy.allowed
+    `${query.orderBy.allowed
       .map((col) => `    ${camelCase(col.langName)}(${quote(col.name)})`)
-      .join(',\n') + ';',
+      .join(',\n')};`,
   );
   lines.push('}');
   return lines;

package/src/emit-queries-swift.ts

@@ -27,14 +27,6 @@ const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
   crdt: '[UInt8]',
 };
 
-function pascalCase(name: string): string {
-  return name
-    .split(/[_-]+/)
-    .filter((p) => p.length > 0)
-    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-    .join('');
-}
-
 /** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name: string): string {
   return snakeToCamel(name);