@syncular/typegen 0.5.1 → 0.7.0

package/src/emit-queries-kotlin.ts

@@ -13,7 +13,12 @@
  */
 import type { IrColumnType } from './ir';
 import { snakeToCamel } from './naming';
-import type { AnalyzedQuery, QueryColumn, QueryParam } from './query';
+import type {
+  AnalyzedQuery,
+  QueryColumn,
+  QuerySyqlPlanBind,
+  QuerySyqlPublicInput,
+} from './query';
 
 const KOTLIN_TYPE: Readonly<Record<IrColumnType, string>> = {
   string: 'String',
@@ -89,28 +94,179 @@ function optionalParamValue(type: IrColumnType, name: string): string {
   }
 }
 
-function isOptionalParam(query: AnalyzedQuery, p: QueryParam): boolean {
-  return (
-    p.optional === true ||
-    p.flag === true ||
-    (query.limit !== undefined && p.name === 'limit')
-  );
+function syqlInput(query: AnalyzedQuery, name: string): QuerySyqlPublicInput {
+  const input = query.syql?.inputs.find((candidate) => candidate.name === name);
+  if (input === undefined) throw new Error(`unknown SYQL input ${name}`);
+  return input;
+}
+
+function syqlKotlinType(type: IrColumnType, nullable: boolean): string {
+  return `${KOTLIN_TYPE[type]}${nullable ? '?' : ''}`;
+}
+
+function syqlControlActive(query: AnalyzedQuery, name: string): string {
+  const input = syqlInput(query, name);
+  const access = camelCase(input.langName);
+  if (input.kind === 'value' && input.default === false) return access;
+  if (input.kind === 'value' && input.nullable) {
+    return `${access} is SyncularQueryPresence.Present`;
+  }
+  if (input.kind === 'value' || input.kind === 'group') {
+    return `${access} != null`;
+  }
+  throw new Error(`${name} is not an activation control`);
+}
+
+function syqlNullablePresenceBind(type: IrColumnType, access: string): string {
+  return `when (val presence = ${access}) { is SyncularQueryPresence.Present -> ${optionalParamValue(type, 'presence.value')}; SyncularQueryPresence.Absent -> JsonValue.Null }`;
+}
+
+function syqlBindExpr(query: AnalyzedQuery, bind: QuerySyqlPlanBind): string {
+  if (bind.kind === 'condition-active') {
+    const active = bind.controls
+      .map((control) => syqlControlActive(query, control))
+      .join(' && ');
+    return `JsonValue.of(${active})`;
+  }
+  const input = syqlInput(query, bind.input);
+  const access = camelCase(input.langName);
+  if (bind.kind === 'limit')
+    return `JsonValue.of(effective${typeName(access)}.toDouble())`;
+  if (bind.kind === 'group-member') {
+    if (input.kind !== 'group') throw new Error('group bind/input mismatch');
+    const member = input.members.find(
+      (candidate) => candidate.name === bind.member,
+    );
+    if (member === undefined)
+      throw new Error(`unknown group member ${bind.member}`);
+    const memberName = camelCase(member.langName);
+    const present = member.nullable
+      ? optionalParamValue(member.type, `value.${memberName}`)
+      : paramValue(member.type, `value.${memberName}`);
+    return `${access}?.let { value -> ${present} } ?: JsonValue.Null`;
+  }
+  if (input.kind !== 'value') throw new Error('value bind/input mismatch');
+  if (input.default === false) return paramValue(input.type, access);
+  if (input.required) {
+    return input.nullable
+      ? optionalParamValue(input.type, access)
+      : paramValue(input.type, access);
+  }
+  return input.nullable
+    ? syqlNullablePresenceBind(input.type, access)
+    : optionalParamValue(input.type, access);
+}
+
+function emitSyqlKotlinTypes(query: AnalyzedQuery): string[] {
+  const lines: string[] = [];
+  for (const input of query.syql?.inputs ?? []) {
+    if (input.kind === 'group') {
+      const name = `${typeName(query.name)}${typeName(input.langName)}`;
+      lines.push(`data class ${name}(`);
+      for (const member of input.members) {
+        lines.push(
+          `    val ${camelCase(member.langName)}: ${syqlKotlinType(member.type, member.nullable)},`,
+        );
+      }
+      lines.push(')', '');
+    } else if (input.kind === 'sort') {
+      const name = `${typeName(query.name)}${typeName(input.langName)}`;
+      lines.push(`enum class ${name}(val index: Int) {`);
+      lines.push(
+        `${input.profiles
+          .map(
+            (profile, index) => `    ${camelCase(profile.langName)}(${index})`,
+          )
+          .join(',\n')};`,
+      );
+      lines.push('}', '');
+    }
+  }
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines;
 }
 
-/** Per-query orderBy allowlist enum (column = the checked SQL column). */
-function emitOrderByEnum(query: AnalyzedQuery): string[] {
-  if (query.orderBy === undefined) return [];
+function emitSyqlKotlinRunner(query: AnalyzedQuery): string[] {
+  const metadata = query.syql;
+  if (metadata === undefined) throw new Error('missing SYQL metadata');
+  const Row = `${typeName(query.name)}Row`;
   const lines: string[] = [];
   lines.push(
-    `/** §6 orderBy allowlist for ${query.name} — checked at generate time. */`,
+    `        val ${query.name}Tables = listOf(${query.tables.map(quote).join(', ')})`,
+    '',
+    `        /** Run the ${query.name} revision-1 SYQL query. */`,
   );
-  lines.push(`enum class ${typeName(query.name)}OrderBy(val column: String) {`);
+  const args = ['client: SyncularClient'];
+  for (const input of metadata.inputs) {
+    const name = camelCase(input.langName);
+    if (input.kind === 'value') {
+      const type = syqlKotlinType(input.type, input.nullable);
+      if (input.required) args.push(`${name}: ${type}`);
+      else if (input.default === false) args.push(`${name}: Boolean = false`);
+      else if (input.nullable) {
+        args.push(
+          `${name}: SyncularQueryPresence<${type}> = SyncularQueryPresence.Absent`,
+        );
+      } else args.push(`${name}: ${type}? = null`);
+    } else if (input.kind === 'group') {
+      args.push(
+        `${name}: ${typeName(query.name)}${typeName(input.langName)}? = null`,
+      );
+    } else if (input.kind === 'sort') {
+      const defaultCase =
+        input.profiles.find((profile) => profile.name === input.defaultProfile)
+          ?.langName ?? input.defaultProfile;
+      const type = `${typeName(query.name)}${typeName(input.langName)}`;
+      args.push(`${name}: ${type} = ${type}.${camelCase(defaultCase)}`);
+    } else {
+      args.push(`${name}: Long? = null`);
+    }
+  }
+  lines.push(`        fun ${query.name}(${args.join(', ')}): List<${Row}> {`);
+  const page = metadata.inputs.find((input) => input.kind === 'limit');
+  if (page?.kind === 'limit') {
+    const name = camelCase(page.langName);
+    lines.push(
+      `            val effective${typeName(name)} = ${name} ?: ${page.defaultSize}L`,
+      `            if (effective${typeName(name)} < 1L || effective${typeName(name)} > ${page.maxSize}L) {`,
+      `                throw SyncularQueryInputException("SYQL_RUNTIME_INVALID_LIMIT", ${quote(`${query.name}: invalid limit`)})`,
+      '            }',
+    );
+  }
+  if (metadata.plan.backend === 'variants') {
+    lines.push('            var activationMask = 0');
+    metadata.plan.activationControls.forEach((control, index) => {
+      lines.push(
+        `            if (${syqlControlActive(query, control)}) activationMask = activationMask or ${2 ** index}`,
+      );
+    });
+  }
+  const sort = metadata.inputs.find((input) => input.kind === 'sort');
+  const profileCount = sort?.kind === 'sort' ? sort.profiles.length : 1;
+  const sortIndex =
+    sort?.kind === 'sort' ? `${camelCase(sort.langName)}.index` : '0';
+  const index =
+    metadata.plan.backend === 'variants'
+      ? `activationMask * ${profileCount} + ${sortIndex}`
+      : sortIndex;
   lines.push(
-    `${query.orderBy.allowed
-      .map((col) => `    ${camelCase(col.langName)}(${quote(col.name)})`)
-      .join(',\n')};`,
+    `            val statementIndex = ${index}`,
+    '            val selected: Pair<String, List<JsonValue>> = when (statementIndex) {',
+  );
+  metadata.plan.statements.forEach((statement, statementIndex) => {
+    const binds = statement.binds
+      .map((bind) => syqlBindExpr(query, bind))
+      .join(', ');
+    lines.push(
+      `                ${statementIndex} -> Pair(${quote(statement.positionalSql)}, listOf(${binds}))`,
+    );
+  });
+  lines.push(
+    '                else -> error("invalid generated SYQL statement index")',
+    '            }',
+    `            return client.query(selected.first, selected.second).mapNotNull { ${Row}.fromRow(it) }`,
+    '        }',
   );
-  lines.push('}');
   return lines;
 }
 
@@ -146,65 +302,33 @@ function emitDataClass(query: AnalyzedQuery): string[] {
 }
 
 function emitRunner(query: AnalyzedQuery): string[] {
+  if (query.syql !== undefined) return emitSyqlKotlinRunner(query);
   const Row = `${typeName(query.name)}Row`;
   const lines: string[] = [];
   lines.push(
     `        val ${query.name}Tables = listOf(${query.tables.map(quote).join(', ')})`,
   );
-  if (query.orderBy !== undefined) {
-    lines.push(
-      `        private const val ${query.name}SqlBase = ${quote(query.positionalSqlBase ?? '')}`,
-    );
-  } else {
-    lines.push(
-      `        private const val ${query.name}Sql = ${quote(query.positionalSql)}`,
-    );
-  }
+  lines.push(
+    `        private const val ${query.name}Sql = ${quote(query.positionalSql)}`,
+  );
   lines.push('');
   lines.push(`        /** Run the ${query.name} named query (SELECT-only). */`);
   const args: string[] = [];
   for (const p of query.params) {
     const name = camelCase(p.langName);
-    if (isOptionalParam(query, p)) {
-      args.push(`${name}: ${KOTLIN_TYPE[p.type]}? = null`);
-    } else {
-      args.push(`${name}: ${KOTLIN_TYPE[p.type]}`);
-    }
-  }
-  if (query.orderBy !== undefined) {
-    const defaultCase = camelCase(
-      query.orderBy.allowed.find((c) => c.name === query.orderBy?.defaultColumn)
-        ?.langName ?? query.orderBy.defaultColumn,
-    );
-    args.push(
-      `orderBy: ${typeName(query.name)}OrderBy = ${typeName(query.name)}OrderBy.${defaultCase}`,
-    );
-    args.push(
-      `dir: SyncularQueryDir = SyncularQueryDir.${query.orderBy.defaultDir.toUpperCase()}`,
-    );
+    args.push(`${name}: ${KOTLIN_TYPE[p.type]}`);
   }
   const signature =
     args.length > 0
       ? `client: SyncularClient, ${args.join(', ')}`
       : 'client: SyncularClient';
   lines.push(`        fun ${query.name}(${signature}): List<${Row}> {`);
-  if (query.orderBy !== undefined) {
-    const limitTail =
-      query.positionalLimitTail !== undefined
-        ? ` + ${quote(query.positionalLimitTail)}`
-        : '';
-    lines.push(
-      `            val sql = ${query.name}SqlBase + " order by " + orderBy.column + " " + dir.sql${limitTail}`,
-    );
-  }
-  const sqlRef = query.orderBy !== undefined ? 'sql' : `${query.name}Sql`;
+  const sqlRef = `${query.name}Sql`;
   if (query.params.length > 0) {
     const binds = query.params
       .map((p) => {
         const name = camelCase(p.langName);
-        return isOptionalParam(query, p)
-          ? optionalParamValue(p.type, name)
-          : paramValue(p.type, name);
+        return paramValue(p.type, name);
       })
       .join(', ');
     lines.push(`            val params = listOf(${binds})`);
@@ -241,6 +365,22 @@ export function emitQueriesKotlinModule(
     ].join('\n'),
   );
 
+  if (queries.some((query) => query.syql !== undefined)) {
+    parts.push(
+      [
+        'sealed class SyncularQueryPresence<out T> {',
+        '    object Absent : SyncularQueryPresence<Nothing>()',
+        '    data class Present<T>(val value: T) : SyncularQueryPresence<T>()',
+        '}',
+        '',
+        'class SyncularQueryInputException(',
+        '    val code: String,',
+        '    override val message: String,',
+        ') : IllegalArgumentException(message)',
+      ].join('\n'),
+    );
+  }
+
   // Row-decode + bind helpers (package-private; distinct names so they don't
   // clash with the schema file's rowBool/rowBytes in the same package).
   parts.push(
@@ -266,22 +406,10 @@ export function emitQueriesKotlinModule(
     ].join('\n'),
   );
 
-  if (queries.some((q) => q.orderBy !== undefined)) {
-    parts.push(
-      [
-        '/** §6 orderBy direction (shared by every orderBy-knob query). */',
-        'enum class SyncularQueryDir(val sql: String) {',
-        '    ASC("asc"),',
-        '    DESC("desc");',
-        '}',
-      ].join('\n'),
-    );
-  }
-
   for (const query of queries) {
+    const syqlTypes = emitSyqlKotlinTypes(query);
+    if (syqlTypes.length > 0) parts.push(syqlTypes.join('\n'));
     parts.push(emitDataClass(query).join('\n'));
-    const orderByEnum = emitOrderByEnum(query);
-    if (orderByEnum.length > 0) parts.push(orderByEnum.join('\n'));
   }
 
   const objLines: string[] = [];

package/src/emit-queries-swift.ts

@@ -14,7 +14,12 @@
  */
 import type { IrColumnType } from './ir';
 import { snakeToCamel } from './naming';
-import type { AnalyzedQuery, QueryColumn, QueryParam } from './query';
+import type {
+  AnalyzedQuery,
+  QueryColumn,
+  QuerySyqlPlanBind,
+  QuerySyqlPublicInput,
+} from './query';
 
 const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
   string: 'String',
@@ -26,6 +31,10 @@ const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
   blob_ref: 'String',
   crdt: '[UInt8]',
 };
+const SYQL_SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
+  ...SWIFT_TYPE,
+  integer: 'Int64',
+};
 
 /** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name: string): string {
@@ -93,12 +102,192 @@ function optionalParamValue(type: IrColumnType, name: string): string {
   }
 }
 
-function isOptionalParam(query: AnalyzedQuery, p: QueryParam): boolean {
-  return (
-    p.optional === true ||
-    p.flag === true ||
-    (query.limit !== undefined && p.name === 'limit')
+function syqlInput(query: AnalyzedQuery, name: string): QuerySyqlPublicInput {
+  const input = query.syql?.inputs.find((candidate) => candidate.name === name);
+  if (input === undefined) throw new Error(`unknown SYQL input ${name}`);
+  return input;
+}
+
+function syqlSwiftType(type: IrColumnType, nullable: boolean): string {
+  return `${SYQL_SWIFT_TYPE[type]}${nullable ? '?' : ''}`;
+}
+
+function syqlControlActive(query: AnalyzedQuery, name: string): string {
+  const input = syqlInput(query, name);
+  const access = camelCase(input.langName);
+  if (input.kind === 'value' && input.default === false) return access;
+  if (input.kind === 'value' && input.nullable) {
+    return `{ if case .present = ${access} { return true }; return false }()`;
+  }
+  if (input.kind === 'value' || input.kind === 'group') {
+    return `${access} != nil`;
+  }
+  throw new Error(`${name} is not an activation control`);
+}
+
+function syqlNullablePresenceBind(type: IrColumnType, access: string): string {
+  return `{ () -> JSONValue in switch ${access} { case .absent: return .null; case .present(let value): return ${optionalParamValue(type, 'value')} } }()`;
+}
+
+function syqlBindExpr(query: AnalyzedQuery, bind: QuerySyqlPlanBind): string {
+  if (bind.kind === 'condition-active') {
+    const active = bind.controls
+      .map((control) => syqlControlActive(query, control))
+      .join(' && ');
+    return `.bool(${active})`;
+  }
+  const input = syqlInput(query, bind.input);
+  const access = camelCase(input.langName);
+  if (bind.kind === 'limit')
+    return `.number(Double(effective${typeName(access)}))`;
+  if (bind.kind === 'group-member') {
+    if (input.kind !== 'group') throw new Error('group bind/input mismatch');
+    const member = input.members.find(
+      (candidate) => candidate.name === bind.member,
+    );
+    if (member === undefined)
+      throw new Error(`unknown group member ${bind.member}`);
+    const memberName = camelCase(member.langName);
+    const present = member.nullable
+      ? optionalParamValue(member.type, `value.${memberName}`)
+      : paramValue(member.type, `value.${memberName}`);
+    return `${access}.map { value in ${present} } ?? .null`;
+  }
+  if (input.kind !== 'value') throw new Error('value bind/input mismatch');
+  if (input.default === false) return paramValue(input.type, access);
+  if (input.required) {
+    return input.nullable
+      ? optionalParamValue(input.type, access)
+      : paramValue(input.type, access);
+  }
+  return input.nullable
+    ? syqlNullablePresenceBind(input.type, access)
+    : optionalParamValue(input.type, access);
+}
+
+function emitSyqlSwiftTypes(query: AnalyzedQuery): string[] {
+  const lines: string[] = [];
+  for (const input of query.syql?.inputs ?? []) {
+    if (input.kind === 'group') {
+      const name = `${typeName(query.name)}${typeName(input.langName)}`;
+      lines.push(`public struct ${name}: Sendable {`);
+      for (const member of input.members) {
+        lines.push(
+          `    public let ${camelCase(member.langName)}: ${syqlSwiftType(member.type, member.nullable)}`,
+        );
+      }
+      const args = input.members
+        .map(
+          (member) =>
+            `${camelCase(member.langName)}: ${syqlSwiftType(member.type, member.nullable)}`,
+        )
+        .join(', ');
+      lines.push(`    public init(${args}) {`);
+      for (const member of input.members) {
+        const name = camelCase(member.langName);
+        lines.push(`        self.${name} = ${name}`);
+      }
+      lines.push('    }', '}', '');
+    } else if (input.kind === 'sort') {
+      const name = `${typeName(query.name)}${typeName(input.langName)}`;
+      lines.push(`public enum ${name}: Int, Sendable {`);
+      input.profiles.forEach((profile, index) => {
+        lines.push(`    case ${camelCase(profile.langName)} = ${index}`);
+      });
+      lines.push('}', '');
+    }
+  }
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function emitSyqlSwiftRunner(query: AnalyzedQuery): string[] {
+  const metadata = query.syql;
+  if (metadata === undefined) throw new Error('missing SYQL metadata');
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(
+    `    public static let ${query.name}Tables = [${query.tables.map(quote).join(', ')}]`,
+    '',
+    `    /// Run the ${query.name} revision-1 SYQL query.`,
+  );
+  const args = ['client: SyncularClient'];
+  for (const input of metadata.inputs) {
+    const name = camelCase(input.langName);
+    if (input.kind === 'value') {
+      const type = syqlSwiftType(input.type, input.nullable);
+      if (input.required) args.push(`${name}: ${type}`);
+      else if (input.default === false) args.push(`${name}: Bool = false`);
+      else if (input.nullable)
+        args.push(`${name}: SyncularQueryPresence<${type}> = .absent`);
+      else args.push(`${name}: ${type}? = nil`);
+    } else if (input.kind === 'group') {
+      args.push(
+        `${name}: ${typeName(query.name)}${typeName(input.langName)}? = nil`,
+      );
+    } else if (input.kind === 'sort') {
+      const defaultCase =
+        input.profiles.find((profile) => profile.name === input.defaultProfile)
+          ?.langName ?? input.defaultProfile;
+      args.push(
+        `${name}: ${typeName(query.name)}${typeName(input.langName)} = .${camelCase(defaultCase)}`,
+      );
+    } else {
+      args.push(`${name}: Int? = nil`);
+    }
+  }
+  lines.push(
+    `    public static func ${query.name}(${args.join(', ')}) throws -> [${Row}] {`,
+  );
+  const page = metadata.inputs.find((input) => input.kind === 'limit');
+  if (page?.kind === 'limit') {
+    const name = camelCase(page.langName);
+    lines.push(
+      `        let effective${typeName(name)} = ${name} ?? ${page.defaultSize}`,
+      `        guard effective${typeName(name)} >= 1 && effective${typeName(name)} <= ${page.maxSize} else {`,
+      `            throw SyncularQueryInputError(code: "SYQL_RUNTIME_INVALID_LIMIT", message: ${quote(`${query.name}: invalid limit`)})`,
+      '        }',
+    );
+  }
+  if (metadata.plan.backend === 'variants') {
+    lines.push('        var activationMask = 0');
+    metadata.plan.activationControls.forEach((control, index) => {
+      lines.push(
+        `        if ${syqlControlActive(query, control)} { activationMask |= ${2 ** index} }`,
+      );
+    });
+  }
+  const sort = metadata.inputs.find((input) => input.kind === 'sort');
+  const profileCount = sort?.kind === 'sort' ? sort.profiles.length : 1;
+  const sortIndex =
+    sort?.kind === 'sort' ? `${camelCase(sort.langName)}.rawValue` : '0';
+  const index =
+    metadata.plan.backend === 'variants'
+      ? `activationMask * ${profileCount} + ${sortIndex}`
+      : sortIndex;
+  lines.push(
+    `        let statementIndex = ${index}`,
+    '        let selected: (String, [JSONValue])',
+    '        switch statementIndex {',
   );
+  metadata.plan.statements.forEach((statement, statementIndex) => {
+    const binds = statement.binds
+      .map((bind) => syqlBindExpr(query, bind))
+      .join(', ');
+    lines.push(
+      `        case ${statementIndex}: selected = (${quote(statement.positionalSql)}, [${binds}])`,
+    );
+  });
+  lines.push(
+    '        default: preconditionFailure("invalid generated SYQL statement index")',
+    '        }',
+    '        return try client.query(selected.0, params: selected.1).compactMap { row in',
+    '            guard case let .object(fields) = row else { return nil }',
+    `            return ${Row}(row: fields)`,
+    '        }',
+    '    }',
+  );
+  return lines;
 }
 
 function emitRowStruct(query: AnalyzedQuery): string[] {
@@ -129,54 +318,22 @@ function emitRowStruct(query: AnalyzedQuery): string[] {
   return lines;
 }
 
-/** Per-query orderBy allowlist enum (rawValue = the checked SQL column). */
-function emitOrderByEnum(query: AnalyzedQuery): string[] {
-  if (query.orderBy === undefined) return [];
-  const lines: string[] = [];
-  lines.push(
-    `/// §6 orderBy allowlist for ${query.name} — checked at generate time.`,
-  );
-  lines.push(`public enum ${typeName(query.name)}OrderBy: String, Sendable {`);
-  for (const col of query.orderBy.allowed) {
-    lines.push(`    case ${camelCase(col.langName)} = ${quote(col.name)}`);
-  }
-  lines.push('}');
-  return lines;
-}
-
 function emitRunner(query: AnalyzedQuery): string[] {
+  if (query.syql !== undefined) return emitSyqlSwiftRunner(query);
   const Row = `${typeName(query.name)}Row`;
   const lines: string[] = [];
   lines.push(
     `    public static let ${query.name}Tables = [${query.tables.map(quote).join(', ')}]`,
   );
-  if (query.orderBy !== undefined) {
-    lines.push(
-      `    private static let ${query.name}SqlBase = ${quote(query.positionalSqlBase ?? '')}`,
-    );
-  } else {
-    lines.push(
-      `    private static let ${query.name}Sql = ${quote(query.positionalSql)}`,
-    );
-  }
+  lines.push(
+    `    private static let ${query.name}Sql = ${quote(query.positionalSql)}`,
+  );
   lines.push('');
   lines.push(`    /// Run the ${query.name} named query (SELECT-only).`);
   const args: string[] = [];
   for (const p of query.params) {
     const name = camelCase(p.langName);
-    if (isOptionalParam(query, p)) {
-      args.push(`${name}: ${SWIFT_TYPE[p.type]}? = nil`);
-    } else {
-      args.push(`${name}: ${SWIFT_TYPE[p.type]}`);
-    }
-  }
-  if (query.orderBy !== undefined) {
-    const defaultCase = camelCase(
-      query.orderBy.allowed.find((c) => c.name === query.orderBy?.defaultColumn)
-        ?.langName ?? query.orderBy.defaultColumn,
-    );
-    args.push(`orderBy: ${typeName(query.name)}OrderBy = .${defaultCase}`);
-    args.push(`dir: SyncularQueryDir = .${query.orderBy.defaultDir}`);
+    args.push(`${name}: ${SWIFT_TYPE[p.type]}`);
   }
   const signature =
     args.length > 0
@@ -185,21 +342,12 @@ function emitRunner(query: AnalyzedQuery): string[] {
   lines.push(
     `    public static func ${query.name}(${signature}) throws -> [${Row}] {`,
   );
-  const sqlExpr =
-    query.orderBy !== undefined
-      ? `${query.name}SqlBase + " order by " + orderBy.rawValue + " " + dir.rawValue${query.positionalLimitTail !== undefined ? ` + ${quote(query.positionalLimitTail)}` : ''}`
-      : `${query.name}Sql`;
-  if (query.orderBy !== undefined) {
-    lines.push(`        let sql = ${sqlExpr}`);
-  }
-  const sqlRef = query.orderBy !== undefined ? 'sql' : `${query.name}Sql`;
+  const sqlRef = `${query.name}Sql`;
   if (query.params.length > 0) {
     const binds = query.params
       .map((p) => {
         const name = camelCase(p.langName);
-        return isOptionalParam(query, p)
-          ? optionalParamValue(p.type, name)
-          : paramValue(p.type, name);
+        return paramValue(p.type, name);
       })
       .join(', ');
     lines.push(`        let params: [JSONValue] = [${binds}]`);
@@ -238,6 +386,26 @@ export function emitQueriesSwiftModule(
     ].join('\n'),
   );
 
+  if (queries.some((query) => query.syql !== undefined)) {
+    parts.push(
+      [
+        'public enum SyncularQueryPresence<Value: Sendable>: Sendable {',
+        '    case absent',
+        '    case present(Value)',
+        '}',
+        '',
+        'public struct SyncularQueryInputError: Error, Sendable {',
+        '    public let code: String',
+        '    public let message: String',
+        '    public init(code: String, message: String) {',
+        '        self.code = code',
+        '        self.message = message',
+        '    }',
+        '}',
+      ].join('\n'),
+    );
+  }
+
   parts.push(
     [
       '/// Param-bind helpers shared by the generated query runners.',
@@ -250,22 +418,10 @@ export function emitQueriesSwiftModule(
     ].join('\n'),
   );
 
-  if (queries.some((q) => q.orderBy !== undefined)) {
-    parts.push(
-      [
-        '/// §6 orderBy direction (shared by every orderBy-knob query).',
-        'public enum SyncularQueryDir: String, Sendable {',
-        '    case asc = "asc"',
-        '    case desc = "desc"',
-        '}',
-      ].join('\n'),
-    );
-  }
-
   for (const query of queries) {
+    const syqlTypes = emitSyqlSwiftTypes(query);
+    if (syqlTypes.length > 0) parts.push(syqlTypes.join('\n'));
     parts.push(emitRowStruct(query).join('\n'));
-    const orderByEnum = emitOrderByEnum(query);
-    if (orderByEnum.length > 0) parts.push(orderByEnum.join('\n'));
   }
 
   const enumLines: string[] = [];