create-baresync 0.2.0

package/dist/templates/app/db-helper.ts

@@ -0,0 +1,22 @@
+import { createTauriDrizzleDatabase } from "baresync/db";
+import { lists, todos } from "../../../packages/sync-contract/src/local-synced-schema";
+import {
+  syncCursors,
+  syncOutbox,
+} from "../../../packages/sync-contract/src/local-schema";
+
+export const TABLE = {
+  lists,
+  todos,
+  syncCursors,
+  syncOutbox,
+};
+
+export function createAppDatabase(
+  invoke: (cmd: string, args?: Record<string, unknown>) => Promise<unknown>
+) {
+  return createTauriDrizzleDatabase({
+    invoke,
+    schema: TABLE,
+  });
+}

package/dist/templates/app/drizzle-local-config.ts

@@ -0,0 +1,19 @@
+import type { Config } from "drizzle-kit";
+import {
+  syncCursors,
+  syncOutbox,
+} from "../../packages/sync-contract/src/local-schema";
+
+const schema = {
+  syncCursors,
+  syncOutbox,
+};
+
+export default {
+  dialect: "sqlite",
+  schema,
+  out: "./apps/app/src-tauri/migrations",
+  dbCredentials: {
+    url: "./apps/app/src-tauri/migrations/__PROJECT_NAME__.db",
+  },
+} satisfies Config;

package/dist/templates/app/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "__PROJECT_NAME__-app",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "db:generate:local": "drizzle-kit generate --config drizzle.local.config.ts",
+    "tauri:build": "tauri build",
+    "tauri:dev": "tauri dev"
+  },
+  "dependencies": {
+    "baresync": "^0.2.0",
+    "drizzle-orm": "^0.45.2"
+  },
+  "devDependencies": {
+    "drizzle-kit": "0.31.4"
+  }
+}

package/dist/templates/app/src/lib.rs

@@ -0,0 +1,21 @@
+use tauri_plugin_baresync::builder::Builder as BaresyncBuilder;
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
+        .init();
+    tauri::Builder::default()
+        .plugin(
+            BaresyncBuilder::new()
+                .api_base_url("http://127.0.0.1:3001")
+                .db_path("baresync.db")
+                .contract_json(include_str!(
+                    "../../../../packages/sync-contract/generated/__CONTRACT_DATE__/sync-contract.json"
+                ))
+                .migrations_path("migrations")
+                .poll_interval_secs(30)
+                .build(),
+        )
+        .run(tauri::generate_context!())
+        .expect("failed to run app");
+}

package/dist/templates/app/src-tauri/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "__PROJECT_NAME__-app"
+version = "0.1.0"
+edition = "2021"
+build = "build.rs"
+
+[lib]
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+tauri = { version = "2", features = [] }
+tauri-plugin-baresync = "0.2.0"
+env_logger = "0.11"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[workspace]

package/dist/templates/app/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+  tauri_build::build()
+}

package/dist/templates/app/src-tauri/tauri.conf.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "__PROJECT_NAME__",
+  "version": "0.1.0",
+  "identifier": "com.baresync.__PROJECT_NAME__",
+  "build": {
+    "beforeBuildCommand": "node ../../scripts/run-workspace.mjs packages/sync-contract generate",
+    "beforeDevCommand": "node ../../scripts/run-workspace.mjs packages/sync-contract generate",
+    "devUrl": "http://localhost:5173",
+    "frontendDist": "../dist"
+  },
+  "app": {
+    "withGlobalTauri": true,
+    "windows": [
+      {
+        "title": "__PROJECT_NAME__",
+        "width": 1280,
+        "height": 920,
+        "resizable": true
+      }
+    ]
+  },
+  "bundle": {
+    "active": false,
+    "resources": ["migrations/*.sql"]
+  }
+}

package/dist/templates/app/sync-client.ts

@@ -0,0 +1,11 @@
+import { SYNC_SCOPE } from "@sync-contract/constants";
+import { createSyncClient } from "baresync/tauri";
+
+export function createAppSyncClient(
+  invoke: (cmd: string, args?: Record<string, unknown>) => Promise<unknown>
+) {
+  return createSyncClient({
+    scopeId: SYNC_SCOPE,
+    invoke,
+  });
+}

package/dist/templates/root/README.md

@@ -0,0 +1,11 @@
+# __PROJECT_NAME__
+
+Generated with `create-baresync`.
+
+## Commands
+
+- `__PACKAGE_MANAGER__ run install`
+- `__PACKAGE_MANAGER__ run generate:sync`
+- `__PACKAGE_MANAGER__ run migrate:local`
+- `__PACKAGE_MANAGER__ run migrate:server`
+- `__PACKAGE_MANAGER__ run dev`

package/dist/templates/root/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "__PROJECT_NAME__",
+  "private": true,
+  "workspaces": ["apps/*", "packages/*"],
+  "scripts": {
+    "dev": "__DEV_SCRIPT__",
+    "generate:sync": "__RUN_IN_WORKSPACE__ packages/sync-contract generate",
+    "migrate:local": "__RUN_IN_WORKSPACE__ apps/app db:generate:local",
+    "migrate:server": "__RUN_IN_WORKSPACE__ apps/server db:generate"
+  },
+  "devDependencies": {
+    "concurrently": "^9.1.2"
+  }
+}

package/dist/templates/root/scripts/dev.mjs

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+const root = process.cwd();
+const commands = [
+  {
+    name: "server",
+    cwd: path.join(root, "apps/server"),
+    args: ["run", "dev"],
+  },
+  {
+    name: "app",
+    cwd: path.join(root, "apps/app"),
+    args: ["run", "tauri:dev"],
+  },
+];
+
+const children = commands.map((command) =>
+  spawn("__PACKAGE_MANAGER__", command.args, {
+    cwd: command.cwd,
+    shell: true,
+    stdio: "inherit",
+  })
+);
+
+let finished = false;
+
+function finish(code) {
+  if (finished) return;
+  finished = true;
+
+  for (const child of children) {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  }
+
+  process.exit(code);
+}
+
+for (const child of children) {
+  child.on("close", (code) => {
+    if (code && code !== 0) {
+      finish(code);
+      return;
+    }
+
+    if (children.every((item) => item.exitCode !== null || item.signalCode !== null)) {
+      finish(0);
+    }
+  });
+}

package/dist/templates/root/scripts/run-workspace.mjs

@@ -0,0 +1,19 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+const [workspace, script, ...args] = process.argv.slice(2);
+
+if (!workspace || !script) {
+  console.error("Usage: node ./scripts/run-workspace.mjs <workspace> <script> [args...]");
+  process.exit(1);
+}
+
+const child = spawn("__PACKAGE_MANAGER__", ["run", script, ...args], {
+  cwd: path.join(process.cwd(), workspace),
+  shell: true,
+  stdio: "inherit",
+});
+
+child.on("close", (code) => {
+  process.exit(code ?? 1);
+});

package/dist/templates/server/db/client.ts

@@ -0,0 +1,32 @@
+import { Database } from "bun:sqlite";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+
+const DEFAULT_DB_PATH = "./data/__PROJECT_NAME__-server.db";
+
+export interface __ProjectName__DatabaseHandle {
+  db: BunSQLiteDatabase<Record<string, never>>;
+  dbPath: string;
+}
+
+export async function create__ProjectName__Database(): Promise<__ProjectName__DatabaseHandle> {
+  const dbPath = path.resolve(
+    process.cwd(),
+    process.env.__PROJECT_NAME___SERVER_DB_PATH ?? DEFAULT_DB_PATH
+  );
+  await fs.mkdir(path.dirname(dbPath), { recursive: true });
+
+  const sqlite = new Database(dbPath);
+  sqlite.run("PRAGMA journal_mode = WAL");
+  sqlite.run("PRAGMA foreign_keys = ON");
+
+  const db = drizzle(sqlite);
+  migrate(db, {
+    migrationsFolder: path.resolve(process.cwd(), "drizzle"),
+  });
+
+  return { db, dbPath };
+}

package/dist/templates/server/db/v1/sync-repository.ts

@@ -0,0 +1,140 @@
+import { lists, todos } from "@sync-contract/generated/__CONTRACT_DATE__/api-synced-schema";
+import {
+  createDrizzleSyncRepository,
+  type DrizzleSyncReadRow,
+  optionalString,
+  requiredString,
+} from "baresync/server/drizzle";
+import { and, desc, eq, gt, type InferInsertModel } from "drizzle-orm";
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+
+type AppDb = BunSQLiteDatabase<Record<string, never>>;
+
+export interface AppScope {
+  scopeId: string;
+}
+
+export function createAppSyncRepository(db: AppDb) {
+  const repository = createDrizzleSyncRepository({
+    tables: {
+      lists: {
+        buildRow: ({ row, scopeId, syncUpdatedAt, updatedAt }) => ({
+          createdAt: optionalString(row.createdAt) ?? updatedAt,
+          deletedAt: optionalString(row.deletedAt),
+          id: requiredString(row.id, "lists.id"),
+          name: requiredString(row.name, "lists.name"),
+          description: optionalString(row.description),
+          scopeId,
+          syncUpdatedAt,
+          updatedAt,
+        }),
+        readLatestRow: async ({ scopeId }) => {
+          const rows = await db
+            .select()
+            .from(lists)
+            .where(eq(lists.scopeId, scopeId))
+            .orderBy(
+              desc(lists.syncUpdatedAt),
+              desc(lists.updatedAt),
+              desc(lists.id)
+            )
+            .limit(1);
+          return rows[0] ?? null;
+        },
+        readRows: ({ cursorTimestamp, scopeId }) =>
+          db
+            .select()
+            .from(lists)
+            .where(
+              cursorTimestamp > 0
+                ? and(
+                    eq(lists.scopeId, scopeId),
+                    gt(lists.syncUpdatedAt, cursorTimestamp)
+                  )
+                : eq(lists.scopeId, scopeId)
+            )
+            .orderBy(
+              desc(lists.syncUpdatedAt),
+              desc(lists.updatedAt),
+              desc(lists.id)
+            ) as Promise<readonly DrizzleSyncReadRow[]>,
+        softDeleteRow: async ({ id, syncUpdatedAt, updatedAt }) => {
+          await db
+            .update(lists)
+            .set({ deletedAt: updatedAt, syncUpdatedAt, updatedAt })
+            .where(eq(lists.id, id));
+        },
+        upsertRow: async (row: InferInsertModel<typeof lists>) => {
+          const { id: _id, ...setValues } = row;
+          await db.insert(lists).values(row).onConflictDoUpdate({
+            target: lists.id,
+            set: setValues,
+          });
+        },
+      },
+      todos: {
+        buildRow: ({ row, scopeId, syncUpdatedAt, updatedAt }) => ({
+          createdAt: optionalString(row.createdAt) ?? updatedAt,
+          deletedAt: optionalString(row.deletedAt),
+          id: requiredString(row.id, "todos.id"),
+          listId: requiredString(row.listId, "todos.listId"),
+          title: requiredString(row.title, "todos.title"),
+          notes: optionalString(row.notes),
+          scopeId,
+          syncUpdatedAt,
+          updatedAt,
+        }),
+        readLatestRow: async ({ scopeId }) => {
+          const rows = await db
+            .select()
+            .from(todos)
+            .where(eq(todos.scopeId, scopeId))
+            .orderBy(
+              desc(todos.syncUpdatedAt),
+              desc(todos.updatedAt),
+              desc(todos.id)
+            )
+            .limit(1);
+          return rows[0] ?? null;
+        },
+        readRows: ({ cursorTimestamp, scopeId }) =>
+          db
+            .select()
+            .from(todos)
+            .where(
+              cursorTimestamp > 0
+                ? and(
+                    eq(todos.scopeId, scopeId),
+                    gt(todos.syncUpdatedAt, cursorTimestamp)
+                  )
+                : eq(todos.scopeId, scopeId)
+            )
+            .orderBy(
+              desc(todos.syncUpdatedAt),
+              desc(todos.updatedAt),
+              desc(todos.id)
+            ) as Promise<readonly DrizzleSyncReadRow[]>,
+        softDeleteRow: async ({ id, syncUpdatedAt, updatedAt }) => {
+          await db
+            .update(todos)
+            .set({ deletedAt: updatedAt, syncUpdatedAt, updatedAt })
+            .where(eq(todos.id, id));
+        },
+        upsertRow: async (row: InferInsertModel<typeof todos>) => {
+          const { id: _id, ...setValues } = row;
+          await db.insert(todos).values(row).onConflictDoUpdate({
+            target: todos.id,
+            set: setValues,
+          });
+        },
+      },
+    },
+  });
+
+  return {
+    tableNames: repository.tableNames,
+    applyPushChanges: repository.applyPushChanges,
+    loadPullChanges: repository.loadPullChanges,
+    loadSyncStatus: repository.loadSyncStatus,
+  };
+}

package/dist/templates/server/drizzle-config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "drizzle-kit";
+import { syncBatchRequests } from "../../packages/sync-contract/src/api-schema";
+
+const schema = {
+  syncBatchRequests,
+};
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema,
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.__PROJECT_NAME___SERVER_DB_PATH ?? "./data/__PROJECT_NAME__-server.db",
+  },
+});

package/dist/templates/server/fallback-instructions.md

@@ -0,0 +1,10 @@
+# Manual mount required
+
+The generated sync route module was written to `src/v1/routes.ts`.
+
+If the entrypoint shape differs from the expected CLI template, mount the routes manually:
+
+- Hono: `app.route("/api/v1/sync", sync)` where `sync` is the default export from `./v1/routes`
+- Elysia: `app.use(sync)` where `sync` is exported from `./v1/routes`
+
+Both route modules are self-contained — they create their own database connection and resolveScope. The database client is at `src/db/client.ts` and the sync repository is at `src/db/v1/sync-repository.ts`.

package/dist/templates/server/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "__PROJECT_NAME__-server",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "db:generate": "drizzle-kit generate --config drizzle.config.ts",
+    "db:migrate": "drizzle-kit migrate --config drizzle.config.ts",
+    "predev": "drizzle-kit migrate --config drizzle.config.ts",
+    "typecheck": "bun x tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "baresync": "^0.2.0"
+  },
+  "devDependencies": {
+    "drizzle-kit": "0.31.4"
+  }
+}

package/dist/templates/server/src/index-elysia.ts

@@ -0,0 +1,12 @@
+import { Elysia } from "elysia";
+import { sync } from "./v1/routes";
+
+const app = new Elysia()
+  .get("/health", () => ({ ok: true }))
+  .use(sync);
+
+app.listen(Number(process.env.PORT ?? "3001"));
+
+console.log(
+  `__PROJECT_NAME__ server listening on http://127.0.0.1:${app.server!.port}`
+);

package/dist/templates/server/src/index-hono.ts

@@ -0,0 +1,13 @@
+import { Hono } from "hono";
+import sync from "./v1/routes";
+
+const app = new Hono();
+
+app.get("/health", (c) => c.json({ ok: true }));
+app.route("/api/v1/sync", sync);
+
+export default app;
+
+console.log(
+  `__PROJECT_NAME__ server listening on http://127.0.0.1:${process.env.PORT ?? "3001"}`
+);

package/dist/templates/server/src/sync-route.ts

@@ -0,0 +1,46 @@
+import { createSyncPullHandler, createSyncPushHandler, createSyncStatusHandler } from "baresync/server";
+
+export function createBaresyncRoutes(deps: {
+  resolveScope: (input: { scopeId: string }) => { ok: true; scope: { scopeId: string } } | { ok: false; body: { error: string }; status: number };
+  repository: {
+    applyPushChanges: (input: { changes: unknown[]; scopeId: string; syncUpdatedAt: number }) => Promise<unknown>;
+    loadPullChanges: (input: { cursor: string; scopeId: string; tables: string[] }) => Promise<unknown>;
+    loadSyncStatus: (input: { cursor: string; scopeId: string }) => Promise<unknown>;
+  };
+  upsertOrder: string[];
+}) {
+  const push = createSyncPushHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    upsertOrder: deps.upsertOrder,
+    applyPushChanges: async ({ changes, scope, syncUpdatedAt }) =>
+      deps.repository.applyPushChanges({
+        changes,
+        scopeId: scope.scopeId,
+        syncUpdatedAt,
+      }),
+  });
+
+  const pull = createSyncPullHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    loadPullChanges: async ({ cursor, scope, tables }) =>
+      deps.repository.loadPullChanges({
+        cursor,
+        scopeId: scope.scopeId,
+        tables,
+      }),
+  });
+
+  const status = createSyncStatusHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    loadSyncStatus: async ({ cursor, scope }) =>
+      deps.repository.loadSyncStatus({
+        cursor,
+        scopeId: scope.scopeId,
+      }),
+  });
+
+  return { pull, push, status };
+}

package/dist/templates/server/src/sync-routes.ts

@@ -0,0 +1,46 @@
+import { createSyncPullHandler, createSyncPushHandler, createSyncStatusHandler } from "baresync/server";
+
+export function createBaresyncRoutes(deps: {
+  resolveScope: (input: { scopeId: string }) => { ok: true; scope: { scopeId: string } } | { ok: false; body: { error: string }; status: number };
+  repository: {
+    applyPushChanges: (input: { changes: unknown[]; scopeId: string; syncUpdatedAt: number }) => Promise<unknown>;
+    loadPullChanges: (input: { cursor: string; scopeId: string; tables: string[] }) => Promise<unknown>;
+    loadSyncStatus: (input: { cursor: string; scopeId: string }) => Promise<unknown>;
+  };
+  upsertOrder: string[];
+}) {
+  const push = createSyncPushHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    upsertOrder: deps.upsertOrder,
+    applyPushChanges: async ({ changes, scope, syncUpdatedAt }) =>
+      deps.repository.applyPushChanges({
+        changes,
+        scopeId: scope.scopeId,
+        syncUpdatedAt,
+      }),
+  });
+
+  const pull = createSyncPullHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    loadPullChanges: async ({ cursor, scope, tables }) =>
+      deps.repository.loadPullChanges({
+        cursor,
+        scopeId: scope.scopeId,
+        tables,
+      }),
+  });
+
+  const status = createSyncStatusHandler({
+    encoding: "json",
+    resolveScope: deps.resolveScope,
+    loadSyncStatus: async ({ cursor, scope }) =>
+      deps.repository.loadSyncStatus({
+        cursor,
+        scopeId: scope.scopeId,
+      }),
+  });
+
+  return { pull, push, status };
+}

package/dist/templates/server/src/v1/routes-elysia.ts

@@ -0,0 +1,62 @@
+import {
+  createSyncPullHandler,
+  createSyncPushHandler,
+  createSyncStatusHandler,
+} from "baresync/server";
+import { Elysia } from "elysia";
+import { SYNC_SCOPE } from "@sync-contract/constants";
+import { db } from "../db/client";
+import { createAppSyncRepository } from "../db/v1/sync-repository";
+
+const resolveScope = ({ scopeId }: { scopeId: string }) => {
+  if (scopeId !== SYNC_SCOPE) {
+    return {
+      ok: false as const,
+      status: 403,
+      body: { error: "single_scope_only" },
+    };
+  }
+
+  return {
+    ok: true as const,
+    scope: { scopeId },
+  };
+};
+
+const repository = createAppSyncRepository(db);
+
+const push = createSyncPushHandler({
+  resolveScope,
+  upsertOrder: repository.tableNames,
+  applyPushChanges: async ({ changes, scope, syncUpdatedAt }) =>
+    repository.applyPushChanges({
+      changes,
+      scopeId: scope.scopeId,
+      syncUpdatedAt,
+    }),
+});
+
+const pull = createSyncPullHandler({
+  limit: 1000,
+  resolveScope,
+  loadPullChanges: async ({ cursor, scope, tables }) =>
+    repository.loadPullChanges({
+      cursor,
+      scopeId: scope.scopeId,
+      tables,
+    }),
+});
+
+const status = createSyncStatusHandler({
+  resolveScope,
+  loadSyncStatus: async ({ cursor, scope }) =>
+    repository.loadSyncStatus({
+      cursor,
+      scopeId: scope.scopeId,
+    }),
+});
+
+export const sync = new Elysia({ prefix: "/api/v1/sync" })
+  .post("/push", async ({ request }) => push(request, {}))
+  .post("/pull", async ({ request }) => pull(request, {}))
+  .post("/status", async ({ request }) => status(request, {}));