create-syncular-app 0.1.3 → 0.2.1

package/template/src/generated/syncular.server.generated.ts

@@ -1,512 +0,0 @@
-// @generated by `cargo run --manifest-path rust/Cargo.toml -p syncular-codegen --`
-// Source: migrations/*.sql and generated Syncular codegen handoff
-
-import { BinarySnapshotTableWriter, createSyncularErrorResponse, type BinarySnapshotColumn, type BinarySnapshotRowsEncoder, type BlobRef } from '@syncular/core';
-import { SyncClientSchemaUnsupportedError, type ApplyOperationResult, type ScopeValues, type ServerApplyOperationContext, type ServerContext, type ServerSnapshotContext, type ServerTableHandler, type StoredScopes, type SyncCoreDb, type SyncOperation, type SyncServerAuth } from '@syncular/server';
-import type { Generated } from 'kysely';
-
-export const syncularGeneratedSchemaVersion = 1 as const;
-export const syncularGeneratedClientSchemaSupport = {
-  current: syncularGeneratedSchemaVersion,
-  minSupported: 1,
-  supported: [1],
-} as const;
-export type SyncularGeneratedSupportedClientSchemaVersion = typeof syncularGeneratedClientSchemaSupport.supported[number];
-export function syncularIsSupportedClientSchemaVersion(schemaVersion: number | null | undefined): schemaVersion is SyncularGeneratedSupportedClientSchemaVersion {
-  if (typeof schemaVersion !== 'number') return false;
-  return (syncularGeneratedClientSchemaSupport.supported as readonly number[]).includes(schemaVersion);
-}
-
-export interface SyncularUnsupportedClientSchemaResultOptions {
-  opIndex: number;
-  schemaVersion: number | null | undefined;
-}
-
-export function syncularUnsupportedClientSchemaResult(options: SyncularUnsupportedClientSchemaResultOptions): ApplyOperationResult {
-  const response = createSyncularErrorResponse('sync.client_schema_unsupported', {
-    message: `Client schema version ${options.schemaVersion ?? 'unknown'} is not supported. Supported client schema versions: ${syncularGeneratedClientSchemaSupport.supported.join(', ')}.`,
-  });
-  return {
-    result: {
-      opIndex: options.opIndex,
-      status: 'error',
-      error: response.message ?? response.error,
-      code: response.code,
-      retriable: response.retryable,
-    },
-    emittedChanges: [],
-  };
-}
-
-export interface SyncularGeneratedColumnSchemaMetadata {
-  name: string;
-  sqlType: string;
-  typeFamily: string;
-  appType: string;
-  nullable: boolean;
-  notnullRequired: boolean;
-  primaryKey: boolean;
-  hasDefault: boolean;
-  defaultSql: string | null;
-  serverVersion: boolean;
-  softDelete: boolean;
-  blobRef: boolean;
-  scope: string | null;
-}
-
-export interface SyncularGeneratedTableSchemaMetadata {
-  name: string;
-  primaryKeyColumn: string;
-  serverVersionColumn: string;
-  softDeleteColumn: string | null;
-  columns: readonly SyncularGeneratedColumnSchemaMetadata[];
-  indexes?: readonly { name: string; sql: string; unique: boolean; partial: boolean; columns: readonly { name: string | null; descending: boolean }[] }[];
-  blobColumns: readonly string[];
-  crdtYjsFields: readonly { field: string; stateColumn: string; containerKey: string; rowIdField: string; kind: string; syncMode: string }[];
-  encryptedFields: readonly { field: string; scope: string; rowIdField: string }[];
-  scopes: readonly { name: string; column: string; source: string; required: boolean }[];
-  subscription: { id: string; params: Record<string, unknown> };
-  sqliteWithoutRowid?: boolean;
-}
-
-export interface SyncularGeneratedClientSchemaMetadata {
-  schemaVersion: number;
-  tables: readonly SyncularGeneratedTableSchemaMetadata[];
-  localBaseSchema?: { tableSetupSql: readonly string[] };
-}
-
-export const syncularGeneratedCurrentClientSchema: SyncularGeneratedClientSchemaMetadata = {
-  "schemaVersion": 1,
-  "tables": [
-    {
-      "blobColumns": [],
-      "columns": [
-        {
-          "appType": "string",
-          "blobRef": false,
-          "defaultSql": null,
-          "hasDefault": false,
-          "name": "id",
-          "notnullRequired": false,
-          "nullable": false,
-          "primaryKey": true,
-          "scope": null,
-          "serverVersion": false,
-          "softDelete": false,
-          "sqlType": "TEXT",
-          "typeFamily": "text"
-        },
-        {
-          "appType": "string",
-          "blobRef": false,
-          "defaultSql": null,
-          "hasDefault": false,
-          "name": "title",
-          "notnullRequired": true,
-          "nullable": false,
-          "primaryKey": false,
-          "scope": null,
-          "serverVersion": false,
-          "softDelete": false,
-          "sqlType": "TEXT",
-          "typeFamily": "text"
-        },
-        {
-          "appType": "integer",
-          "blobRef": false,
-          "defaultSql": "0",
-          "hasDefault": true,
-          "name": "completed",
-          "notnullRequired": true,
-          "nullable": false,
-          "primaryKey": false,
-          "scope": null,
-          "serverVersion": false,
-          "softDelete": false,
-          "sqlType": "INTEGER",
-          "typeFamily": "integer"
-        },
-        {
-          "appType": "string",
-          "blobRef": false,
-          "defaultSql": null,
-          "hasDefault": false,
-          "name": "user_id",
-          "notnullRequired": true,
-          "nullable": false,
-          "primaryKey": false,
-          "scope": "user_id",
-          "serverVersion": false,
-          "softDelete": false,
-          "sqlType": "TEXT",
-          "typeFamily": "text"
-        },
-        {
-          "appType": "integer",
-          "blobRef": false,
-          "defaultSql": "0",
-          "hasDefault": true,
-          "name": "created_at",
-          "notnullRequired": true,
-          "nullable": false,
-          "primaryKey": false,
-          "scope": null,
-          "serverVersion": false,
-          "softDelete": false,
-          "sqlType": "BIGINT",
-          "typeFamily": "integer"
-        },
-        {
-          "appType": "integer",
-          "blobRef": false,
-          "defaultSql": "0",
-          "hasDefault": true,
-          "name": "server_version",
-          "notnullRequired": true,
-          "nullable": false,
-          "primaryKey": false,
-          "scope": null,
-          "serverVersion": true,
-          "softDelete": false,
-          "sqlType": "BIGINT",
-          "typeFamily": "integer"
-        }
-      ],
-      "crdtYjsFields": [],
-      "encryptedFields": [],
-      "name": "tasks",
-      "primaryKeyColumn": "id",
-      "scopes": [
-        {
-          "column": "user_id",
-          "name": "user_id",
-          "required": true,
-          "source": "actorId"
-        }
-      ],
-      "serverVersionColumn": "server_version",
-      "softDeleteColumn": null,
-      "sqliteWithoutRowid": true,
-      "subscription": {
-        "id": "sub-tasks",
-        "params": {}
-      }
-    }
-  ]
-} as const;
-
-export const syncularGeneratedHistoricalClientSchemas: readonly SyncularGeneratedClientSchemaMetadata[] = [] as const;
-export type SyncularGeneratedClientSchema = SyncularGeneratedClientSchemaMetadata;
-export function syncularGeneratedClientSchemaForVersion(schemaVersion: number | null | undefined): SyncularGeneratedClientSchema | null {
-  if (schemaVersion === syncularGeneratedSchemaVersion) return syncularGeneratedCurrentClientSchema;
-  return syncularGeneratedHistoricalClientSchemas.find((schema) => schema.schemaVersion === schemaVersion) ?? null;
-}
-
-export interface SyncularGeneratedValidationError {
-  path: string;
-  message: string;
-}
-
-export type SyncularGeneratedValidationResult<T> = { ok: true; value: T } | { ok: false; errors: SyncularGeneratedValidationError[] };
-
-function syncularGeneratedIsRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-export function syncularGeneratedTableSchemaForVersion(table: string, schemaVersion: number | null | undefined): SyncularGeneratedTableSchemaMetadata | null {
-  const schema = syncularGeneratedClientSchemaForVersion(schemaVersion);
-  return schema?.tables.find((candidate) => candidate.name === table) ?? null;
-}
-
-export function syncularProjectGeneratedClientRowForVersion(table: string, row: Record<string, unknown>, schemaVersion: number | null | undefined): Record<string, unknown> {
-  const tableSchema = syncularGeneratedTableSchemaForVersion(table, schemaVersion);
-  if (!tableSchema) throw new Error(`Unknown table or unsupported client schema version ${schemaVersion ?? 'unknown'} for ${table}`);
-  const projected: Record<string, unknown> = {};
-  for (const column of tableSchema.columns) {
-    if (column.name in row) projected[column.name] = row[column.name];
-  }
-  return projected;
-}
-
-export function syncularValidateGeneratedClientRow(table: string, row: unknown, schemaVersion: number | null | undefined): SyncularGeneratedValidationResult<Record<string, unknown>> {
-  const tableSchema = syncularGeneratedTableSchemaForVersion(table, schemaVersion);
-  if (!tableSchema) return { ok: false, errors: [{ path: table, message: `Unknown table or unsupported client schema version ${schemaVersion ?? 'unknown'}` }] };
-  if (!syncularGeneratedIsRecord(row)) return { ok: false, errors: [{ path: table, message: 'Expected row object' }] };
-  const errors: SyncularGeneratedValidationError[] = [];
-  const columns = new Set(tableSchema.columns.map((column) => column.name));
-  for (const key of Object.keys(row)) {
-    if (!columns.has(key)) errors.push({ path: `${table}.${key}`, message: 'Unknown column' });
-  }
-  for (const column of tableSchema.columns) {
-    if (!(column.name in row)) {
-      errors.push({ path: `${table}.${column.name}`, message: 'Missing column' });
-      continue;
-    }
-    if (row[column.name] == null && !column.nullable) {
-      errors.push({ path: `${table}.${column.name}`, message: 'Column cannot be null' });
-    }
-  }
-  return errors.length === 0 ? { ok: true, value: row } : { ok: false, errors };
-}
-
-export function syncularValidateGeneratedMutationPayload(table: string, payload: unknown, schemaVersion: number | null | undefined): SyncularGeneratedValidationResult<Record<string, unknown> | null> {
-  const tableSchema = syncularGeneratedTableSchemaForVersion(table, schemaVersion);
-  if (!tableSchema) return { ok: false, errors: [{ path: table, message: `Unknown table or unsupported client schema version ${schemaVersion ?? 'unknown'}` }] };
-  if (payload == null) return { ok: true, value: null };
-  if (!syncularGeneratedIsRecord(payload)) return { ok: false, errors: [{ path: table, message: 'Expected mutation payload object or null' }] };
-  const errors: SyncularGeneratedValidationError[] = [];
-  const columns = new Map(tableSchema.columns.map((column) => [column.name, column]));
-  for (const [key, value] of Object.entries(payload)) {
-    const column = columns.get(key);
-    if (!column) {
-      errors.push({ path: `${table}.${key}`, message: 'Unknown column' });
-      continue;
-    }
-    if (value == null && !column.nullable) {
-      errors.push({ path: `${table}.${key}`, message: 'Column cannot be null' });
-    }
-  }
-  return errors.length === 0 ? { ok: true, value: payload } : { ok: false, errors };
-}
-
-export function syncularValidateGeneratedOperation(table: string, op: SyncOperation, schemaVersion: number | null | undefined): SyncularGeneratedValidationResult<SyncOperation> {
-  if (op.table !== table) return { ok: false, errors: [{ path: op.table, message: `Expected operation table ${table}` }] };
-  if (op.op === 'delete') {
-    if (op.payload !== null) return { ok: false, errors: [{ path: `${table}.payload`, message: 'Delete payload must be null' }] };
-    return { ok: true, value: op };
-  }
-  if (op.op !== 'upsert') return { ok: false, errors: [{ path: `${table}.op`, message: `Unsupported operation ${op.op}` }] };
-  if (op.payload == null) return { ok: false, errors: [{ path: `${table}.payload`, message: 'Upsert payload is required' }] };
-  const payload = syncularValidateGeneratedMutationPayload(table, op.payload, schemaVersion);
-  return payload.ok ? { ok: true, value: op } : payload;
-}
-
-export interface SyncularAppDb {
-  tasks: TaskTable;
-}
-
-export interface TaskTable {
-  id: string;
-  title: string;
-  completed: Generated<number>;
-  user_id: string;
-  created_at: Generated<number>;
-  server_version: Generated<number>;
-}
-
-export interface TaskRow {
-  id: string;
-  title: string;
-  completed: number;
-  user_id: string;
-  created_at: number;
-  server_version: number;
-}
-
-export const syncularGeneratedSnapshotBinaryColumns = {
-  tasks: [
-    { name: 'id', type: 'string' },
-    { name: 'title', type: 'string' },
-    { name: 'completed', type: 'integer' },
-    { name: 'user_id', type: 'string' },
-    { name: 'created_at', type: 'integer' },
-    { name: 'server_version', type: 'integer' },
-  ],
-} satisfies Record<keyof SyncularAppDb, readonly BinarySnapshotColumn[]>;
-
-export function encodeTasksBinarySnapshotRows(rows: readonly TaskRow[]): Uint8Array {
-  const writer = new BinarySnapshotTableWriter('tasks', syncularGeneratedSnapshotBinaryColumns.tasks, rows.length);
-  for (const row of rows) {
-    writer.beginRow();
-    writer.writeString(row.id, 'binary snapshot tasks.id');
-    writer.writeString(row.title, 'binary snapshot tasks.title');
-    writer.writeInteger(row.completed, 'binary snapshot tasks.completed');
-    writer.writeString(row.user_id, 'binary snapshot tasks.user_id');
-    writer.writeInteger(row.created_at, 'binary snapshot tasks.created_at');
-    writer.writeInteger(row.server_version, 'binary snapshot tasks.server_version');
-  }
-  return writer.finish();
-}
-
-export const syncularGeneratedSnapshotBinaryEncoders = {
-  tasks: (rows) => encodeTasksBinarySnapshotRows(rows as readonly TaskRow[]),
-} satisfies Record<keyof SyncularAppDb, BinarySnapshotRowsEncoder>;
-
-function syncularGeneratedSnapshotBinaryColumnType(column: SyncularGeneratedColumnSchemaMetadata): BinarySnapshotColumn['type'] {
-  if (column.blobRef || column.appType === 'blobRef') return 'json';
-  switch (column.typeFamily) {
-    case 'integer': return 'integer';
-    case 'real': return 'float';
-    case 'blob': return 'bytes';
-    default: return 'string';
-  }
-}
-
-export function syncularGeneratedSnapshotBinaryColumnsForVersion(table: string, schemaVersion: number | null | undefined): readonly BinarySnapshotColumn[] | null {
-  const tableSchema = syncularGeneratedTableSchemaForVersion(table, schemaVersion);
-  if (!tableSchema) return null;
-  return tableSchema.columns.map((column) => ({
-    name: column.name,
-    type: syncularGeneratedSnapshotBinaryColumnType(column),
-    ...(column.nullable ? { nullable: true } : {}),
-  }));
-}
-
-export function syncularGeneratedSnapshotBinaryEncoderForVersion(table: string, schemaVersion: number | null | undefined): BinarySnapshotRowsEncoder | null {
-  if (schemaVersion !== syncularGeneratedSchemaVersion) return null;
-  return syncularGeneratedSnapshotBinaryEncoders[table as keyof SyncularAppDb] ?? null;
-}
-
-export const syncularGeneratedServerSnapshotBinary = {
-  columns: syncularGeneratedSnapshotBinaryColumns,
-  encoders: syncularGeneratedSnapshotBinaryEncoders,
-  columnsForVersion: syncularGeneratedSnapshotBinaryColumnsForVersion,
-  encoderForVersion: syncularGeneratedSnapshotBinaryEncoderForVersion,
-} as const;
-const syncularGeneratedAppTableRefs = {
-  tasks: {
-    name: 'tasks',
-    primaryKeyColumn: 'id',
-    serverVersionColumn: 'server_version',
-    scopePatterns: ['{user_id}'],
-  },
-} as const;
-
-export const syncularGeneratedApp = {
-  currentSchemaVersion: syncularGeneratedSchemaVersion,
-  clientSchemaSupport: syncularGeneratedClientSchemaSupport,
-  tables: syncularGeneratedAppTableRefs,
-  clientSchemaForVersion: syncularGeneratedClientSchemaForVersion,
-  tableSchemaForVersion: syncularGeneratedTableSchemaForVersion,
-  projectClientRowForVersion: syncularProjectGeneratedClientRowForVersion,
-} as const;
-
-export type SyncularGeneratedAppTableName = keyof typeof syncularGeneratedApp.tables & string;
-export type SyncularGeneratedAppTableRef = typeof syncularGeneratedApp.tables[SyncularGeneratedAppTableName];
-
-function syncularResolveGeneratedAppTable(table: SyncularGeneratedAppTableName | SyncularGeneratedAppTableRef): SyncularGeneratedAppTableRef {
-  return typeof table === 'string' ? syncularGeneratedApp.tables[table] : table;
-}
-
-function syncularGeneratedExtractScopes(table: string, row: Record<string, unknown>): StoredScopes {
-  const tableSchema = syncularGeneratedTableSchemaForVersion(table, syncularGeneratedSchemaVersion);
-  if (!tableSchema) throw new Error(`Unknown generated app table ${table}`);
-  const scopes: StoredScopes = {};
-  for (const scope of tableSchema.scopes) {
-    const value = row[scope.column];
-    if (value == null) {
-      if (scope.required) throw new Error(`Missing required scope column ${table}.${scope.column}`);
-      continue;
-    }
-    scopes[scope.name] = String(value);
-  }
-  return scopes;
-}
-
-function syncularGeneratedValidationErrorResult(opIndex: number, errors: readonly SyncularGeneratedValidationError[]): ApplyOperationResult {
-  const response = createSyncularErrorResponse('sync.invalid_request', {
-    message: errors.map((error) => `${error.path}: ${error.message}`).join('; '),
-  });
-  return {
-    result: { opIndex, status: 'error', error: response.message ?? response.error, code: response.code, retriable: response.retryable },
-    emittedChanges: [],
-  };
-}
-
-function syncularAssertGeneratedEmittedChange(table: string, change: ApplyOperationResult['emittedChanges'][number]): void {
-  if (change.table !== table) throw new Error(`Generated emitted change table ${change.table} does not match handler table ${table}`);
-  if (change.op === 'delete') {
-    if (change.row_json !== null) throw new Error(`Generated delete emitted change ${table}.${change.row_id} must not include row_json`);
-    return;
-  }
-  const validation = syncularValidateGeneratedClientRow(table, change.row_json, syncularGeneratedSchemaVersion);
-  if (!validation.ok) {
-    throw new Error(`Generated emitted change row_json ${table}.${change.row_id} does not match current schema ${syncularGeneratedSchemaVersion}: ${validation.errors.map((error) => `${error.path}: ${error.message}`).join('; ')}`);
-  }
-}
-
-function syncularAssertGeneratedApplyOperationResult(table: string, result: ApplyOperationResult, schemaVersion: number | null | undefined): void {
-  for (const change of result.emittedChanges) syncularAssertGeneratedEmittedChange(table, change);
-  if (result.result.status !== 'conflict') return;
-  const validation = syncularValidateGeneratedClientRow(table, result.result.server_row, schemaVersion);
-  if (!validation.ok) {
-    throw new Error(`Generated conflict server_row ${table} does not match client schema ${schemaVersion}: ${validation.errors.map((error) => `${error.path}: ${error.message}`).join('; ')}`);
-  }
-}
-
-export interface CreateSyncularAppServerHandlerOptions<DB extends SyncCoreDb = SyncCoreDb, Auth extends SyncServerAuth = SyncServerAuth> {
-  table: SyncularGeneratedAppTableName | SyncularGeneratedAppTableRef;
-  dependsOn?: string[];
-  snapshotChunkTtlMs?: number;
-  canRejectSingleOperationWithoutSavepoint?: boolean;
-  resolveScopes(ctx: ServerContext<DB, Auth>): Promise<ScopeValues> | ScopeValues;
-  extractScopes?: (row: Record<string, unknown>) => StoredScopes;
-  snapshot(ctx: ServerSnapshotContext<DB, string, Auth>, params: Record<string, unknown> | undefined): Promise<{ rows: unknown[]; nextCursor: string | null }>;
-  applyOperation(ctx: ServerApplyOperationContext<DB, Auth>, op: SyncOperation, opIndex: number): Promise<ApplyOperationResult>;
-  applyOperationBatch?(ctx: ServerApplyOperationContext<DB, Auth>, operations: { op: SyncOperation; opIndex: number }[]): Promise<ApplyOperationResult[]>;
-}
-
-export function createSyncularAppServerHandler<DB extends SyncCoreDb = SyncCoreDb, Auth extends SyncServerAuth = SyncServerAuth>(options: CreateSyncularAppServerHandlerOptions<DB, Auth>): ServerTableHandler<DB, Auth> {
-  const table = syncularResolveGeneratedAppTable(options.table);
-  const tableName = table.name;
-  const applyOperationBatch = options.applyOperationBatch;
-  const handler: ServerTableHandler<DB, Auth> = {
-    table: tableName,
-    primaryKeyColumn: table.primaryKeyColumn,
-    scopePatterns: [...table.scopePatterns],
-    dependsOn: options.dependsOn,
-    snapshotChunkTtlMs: options.snapshotChunkTtlMs,
-    snapshotBinaryColumns: syncularGeneratedSnapshotBinaryColumns[tableName as keyof SyncularAppDb],
-    snapshotBinaryEncoder: syncularGeneratedSnapshotBinaryEncoders[tableName as keyof SyncularAppDb],
-    snapshotBinaryColumnsForVersion: (schemaVersion) => syncularGeneratedSnapshotBinaryColumnsForVersion(tableName, schemaVersion),
-    snapshotBinaryEncoderForVersion: (schemaVersion) => syncularGeneratedSnapshotBinaryEncoderForVersion(tableName, schemaVersion),
-    projectChangeForVersion(change, schemaVersion) {
-      if (change.row_json == null) return change;
-      if (!syncularGeneratedIsRecord(change.row_json)) throw new Error(`Generated pull change row_json ${tableName}.${change.row_id} must be an object`);
-      const row = syncularProjectGeneratedClientRowForVersion(tableName, change.row_json, schemaVersion);
-      const validation = syncularValidateGeneratedClientRow(tableName, row, schemaVersion);
-      if (!validation.ok) throw new Error(`Generated pull change row_json ${tableName}.${change.row_id} does not match client schema ${schemaVersion}: ${validation.errors.map((error) => `${error.path}: ${error.message}`).join('; ')}`);
-      return { ...change, row_json: row };
-    },
-    canRejectSingleOperationWithoutSavepoint: options.canRejectSingleOperationWithoutSavepoint,
-    resolveScopes: async (ctx) => options.resolveScopes(ctx),
-    extractScopes: options.extractScopes ?? ((row) => syncularGeneratedExtractScopes(tableName, row)),
-    async snapshot(ctx, params) {
-      if (!syncularIsSupportedClientSchemaVersion(ctx.schemaVersion)) {
-        throw new SyncClientSchemaUnsupportedError({ schemaVersion: ctx.schemaVersion, supportedSchemaVersions: syncularGeneratedClientSchemaSupport.supported });
-      }
-      const page = await options.snapshot(ctx, params);
-      const rows = page.rows ?? [];
-      for (let index = 0; index < rows.length; index += 1) {
-        const validation = syncularValidateGeneratedClientRow(tableName, rows[index], ctx.schemaVersion);
-        if (!validation.ok) {
-          throw new Error(`Generated snapshot row ${tableName}[${index}] does not match client schema ${ctx.schemaVersion}: ${validation.errors.map((error) => `${error.path}: ${error.message}`).join('; ')}`);
-        }
-      }
-      return page;
-    },
-    async applyOperation(ctx, op, opIndex) {
-      if (!syncularIsSupportedClientSchemaVersion(ctx.schemaVersion)) {
-        return syncularUnsupportedClientSchemaResult({ opIndex, schemaVersion: ctx.schemaVersion });
-      }
-      const validation = syncularValidateGeneratedOperation(tableName, op, ctx.schemaVersion);
-      if (!validation.ok) return syncularGeneratedValidationErrorResult(opIndex, validation.errors);
-      const result = await options.applyOperation(ctx, op, opIndex);
-      syncularAssertGeneratedApplyOperationResult(tableName, result, ctx.schemaVersion);
-      return result;
-    },
-    applyOperationBatch: applyOperationBatch ? async (ctx, operations) => {
-      for (const { op, opIndex } of operations) {
-        if (!syncularIsSupportedClientSchemaVersion(ctx.schemaVersion)) {
-          return [syncularUnsupportedClientSchemaResult({ opIndex, schemaVersion: ctx.schemaVersion })];
-        }
-        const validation = syncularValidateGeneratedOperation(tableName, op, ctx.schemaVersion);
-        if (!validation.ok) return [syncularGeneratedValidationErrorResult(opIndex, validation.errors)];
-      }
-      const results = await applyOperationBatch(ctx, operations);
-      for (const result of results) syncularAssertGeneratedApplyOperationResult(tableName, result, ctx.schemaVersion);
-      return results;
-    } : undefined,
-  };
-  return handler;
-}

package/template/src/main.tsx

@@ -1,5 +0,0 @@
-import { createRoot } from 'react-dom/client';
-import { App } from './app';
-import './styles.css';
-
-createRoot(document.getElementById('root')!).render(<App />);

package/template/src/server/sync-server.ts

@@ -1,129 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { createDatabase } from '@syncular/core';
-import {
-  createServerHandler,
-  ensureSyncSchema,
-  type SyncCoreDb,
-} from '@syncular/server';
-import { createBunSqliteDialect } from '@syncular/server/bun-sqlite';
-import { createSyncServer } from '@syncular/server/hono';
-import { createSqliteServerDialect } from '@syncular/server/sqlite';
-import { Hono } from 'hono';
-import { upgradeWebSocket, websocket } from 'hono/bun';
-import type { Kysely } from 'kysely';
-// Regenerate the generated modules with `bun run codegen` after changing
-// migrations/ or syncular.app.ts.
-import { syncularGeneratedCodecs } from '../generated/syncular.generated';
-import type { SyncularAppDb } from '../generated/syncular.server.generated';
-
-interface AppServerDb extends SyncCoreDb, SyncularAppDb {}
-
-interface AppSyncServer {
-  origin: string;
-  close(): Promise<void>;
-}
-
-/**
- * Demo auth: every request authenticates as the same single user via a static
- * bearer token. Replace `authenticate` with your real session/token check and
- * derive `actorId` from it.
- */
-const DEMO_TOKEN = 'demo-user';
-const DEMO_ACTOR_ID = 'demo-user';
-
-export async function startSyncServer(
-  options: { port?: number; databasePath?: string } = {}
-): Promise<AppSyncServer> {
-  const databasePath =
-    options.databasePath ??
-    process.env.SYNC_DB_PATH ??
-    path.resolve(import.meta.dir, '../../data/sync.sqlite');
-  if (databasePath !== ':memory:') {
-    mkdirSync(path.dirname(databasePath), { recursive: true });
-  }
-
-  const dialect = createSqliteServerDialect();
-  const db = createDatabase<AppServerDb>({
-    dialect: createBunSqliteDialect({ path: databasePath }),
-    family: 'sqlite',
-  });
-
-  await ensureSyncSchema(db, dialect);
-  await ensureAppTables(db);
-
-  const { syncRoutes } = createSyncServer<AppServerDb, { actorId: string }>({
-    db,
-    dialect,
-    sync: {
-      handlers: [
-        createServerHandler<
-          AppServerDb,
-          SyncularAppDb,
-          'tasks',
-          { actorId: string }
-        >({
-          table: 'tasks',
-          scopes: ['user:{user_id}'],
-          codecs: syncularGeneratedCodecs,
-          resolveScopes: async (ctx) => ({ user_id: [ctx.actorId] }),
-        }),
-      ],
-      authenticate: (request) => {
-        const authorization = request.headers.get('authorization');
-        const token = new URL(request.url).searchParams.get('token');
-        if (authorization !== `Bearer ${DEMO_TOKEN}` && token !== DEMO_TOKEN) {
-          return null;
-        }
-        return { actorId: DEMO_ACTOR_ID };
-      },
-    },
-    routes: {
-      cors: ['http://127.0.0.1:*', 'http://localhost:*'],
-      rateLimit: false,
-      websocket: {
-        allowedOrigins: ['http://127.0.0.1:*', 'http://localhost:*'],
-        heartbeatIntervalMs: 15_000,
-      },
-    },
-    upgradeWebSocket,
-  });
-
-  const app = new Hono()
-    .get('/health', (c) => c.json({ ok: true }))
-    .route('/sync', syncRoutes);
-
-  const server = Bun.serve({
-    hostname: '127.0.0.1',
-    port: options.port ?? 4100,
-    fetch: app.fetch,
-    websocket,
-    idleTimeout: 0,
-  });
-
-  return {
-    origin: `http://127.0.0.1:${server.port}`,
-    async close() {
-      server.stop(true);
-      await db.destroy();
-    },
-  };
-}
-
-/**
- * The server owns its copy of the synced tables. Keep this in sync with
- * migrations/*.sql (the client installs the same schema locally from the
- * generated embedded migrations).
- */
-async function ensureAppTables(db: Kysely<AppServerDb>) {
-  await db.schema
-    .createTable('tasks')
-    .ifNotExists()
-    .addColumn('id', 'text', (col) => col.primaryKey())
-    .addColumn('title', 'text', (col) => col.notNull())
-    .addColumn('completed', 'integer', (col) => col.notNull().defaultTo(0))
-    .addColumn('user_id', 'text', (col) => col.notNull())
-    .addColumn('created_at', 'bigint', (col) => col.notNull().defaultTo(0))
-    .addColumn('server_version', 'bigint', (col) => col.notNull().defaultTo(0))
-    .execute();
-}