create-baresync 0.2.0

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

@@ -0,0 +1,65 @@
+import { Hono } from "hono";
+import { SYNC_SCOPE } from "@sync-contract/constants";
+import {
+  createSyncPullHandler,
+  createSyncPushHandler,
+  createSyncStatusHandler,
+} from "baresync/server";
+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,
+    }),
+});
+
+const sync = new Hono();
+
+sync.post("/push", (c) => push(c.req.raw, {}));
+sync.post("/pull", (c) => pull(c.req.raw, {}));
+sync.post("/status", (c) => status(c.req.raw, {}));
+
+export default sync;

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

@@ -0,0 +1,76 @@
+import { Hono } from "hono";
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import {
+  createSyncPullHandler,
+  createSyncPushHandler,
+  createSyncStatusHandler,
+} from "baresync/server";
+import {
+  createAppSyncRepository,
+  type AppScope,
+} from "../db/v1/sync-repository";
+
+type AppDb = BunSQLiteDatabase<Record<string, never>>;
+
+export function createV1Routes({
+  db,
+  resolveScope,
+}: {
+  db: AppDb;
+  resolveScope: ({
+    scopeId,
+  }: {
+    scopeId: string;
+  }) =>
+    | { ok: true; scope: AppScope }
+    | { ok: false; status: number; body: { error: string } };
+}) {
+  const repository = createAppSyncRepository(db);
+
+  const app = new Hono();
+
+  app.post("/push", async (c) => {
+    const handler = createSyncPushHandler({
+      encoding: "json",
+      resolveScope,
+      upsertOrder: repository.tableNames,
+      applyPushChanges: async ({ changes, scope, syncUpdatedAt }) =>
+        repository.applyPushChanges({
+          changes,
+          scopeId: scope.scopeId,
+          syncUpdatedAt,
+        }),
+    });
+    return handler(c.req.raw, {});
+  });
+
+  app.post("/pull", async (c) => {
+    const handler = createSyncPullHandler({
+      encoding: "json",
+      limit: 1000,
+      resolveScope,
+      loadPullChanges: async ({ cursor, scope, tables }) =>
+        repository.loadPullChanges({
+          cursor,
+          scopeId: scope.scopeId,
+          tables,
+        }),
+    });
+    return handler(c.req.raw, {});
+  });
+
+  app.post("/status", async (c) => {
+    const handler = createSyncStatusHandler({
+      encoding: "json",
+      resolveScope,
+      loadSyncStatus: async ({ cursor, scope }) =>
+        repository.loadSyncStatus({
+          cursor,
+          scopeId: scope.scopeId,
+        }),
+    });
+    return handler(c.req.raw, {});
+  });
+
+  return app;
+}

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

@@ -0,0 +1,17 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+const dbPath = path.resolve(
+  process.cwd(),
+  process.env.__PROJECT_NAME___SERVER_DB_PATH ?? "./data/__PROJECT_NAME__-server.db"
+);
+
+await fs.mkdir(path.dirname(dbPath), { recursive: true });
+
+const sqlite = new Database(dbPath);
+sqlite.pragma("journal_mode = WAL");
+sqlite.pragma("foreign_keys = ON");
+
+export const db = drizzle(sqlite);

package/dist/templates/server/src-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 { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+
+type AppDb = BetterSQLite3Database<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/sync-contract/generate.ts

@@ -0,0 +1,7 @@
+import { generateSyncArtifacts } from "baresync/generator";
+import { syncGeneratorConfig } from "./sync.config";
+
+generateSyncArtifacts(
+  syncGeneratorConfig.contract,
+  syncGeneratorConfig.outputDir
+);

package/dist/templates/sync-contract/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@baresync/sync-contract",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/constants.ts",
+    "./constants": "./src/constants.ts",
+    "./api-schema": "./src/api-schema.ts",
+    "./api-synced-schema": "./src/api-synced-schema.ts",
+    "./local-schema": "./src/local-schema.ts",
+    "./local-synced-schema": "./src/local-synced-schema.ts",
+    "./generated/*": "./generated/*"
+  },
+  "scripts": {
+    "generate": "bunx baresync generate",
+    "typecheck": "bun x tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "baresync": "^0.2.0",
+    "drizzle-orm": "^0.45.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.10"
+  }
+}

package/dist/templates/sync-contract/src/api-schema.ts

@@ -0,0 +1,3 @@
+import { createSyncBatchRequestsTable } from "baresync/schema";
+
+export const syncBatchRequests = createSyncBatchRequestsTable();

package/dist/templates/sync-contract/src/api-synced-schema.ts

@@ -0,0 +1,20 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { apiSyncColumns } from "baresync/schema";
+
+export const lists = sqliteTable("lists", {
+  id: text("id").primaryKey(),
+  scopeId: text("scope_id").notNull(),
+  name: text("name").notNull(),
+  description: text("description"),
+  ...apiSyncColumns(),
+});
+
+export const todos = sqliteTable("todos", {
+  id: text("id").primaryKey(),
+  scopeId: text("scope_id").notNull(),
+  listId: text("list_id").notNull(),
+  title: text("title").notNull(),
+  completed: integer("completed", { mode: "boolean" }).notNull().default(false),
+  notes: text("notes"),
+  ...apiSyncColumns(),
+});

package/dist/templates/sync-contract/src/constants.ts

@@ -0,0 +1,4 @@
+export const PROJECT_NAME = "__PROJECT_NAME__";
+export const SYNC_SCOPE = "default";
+export const LISTS_TABLE_NAME = "lists";
+export const TODOS_TABLE_NAME = "todos";

package/dist/templates/sync-contract/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./api-schema";
+export * from "./api-synced-schema";
+export * from "./constants";
+export * from "./local-schema";
+export * from "./local-synced-schema";

package/dist/templates/sync-contract/src/local-schema.ts

@@ -0,0 +1,4 @@
+import { createSyncCursorsTable, createSyncOutboxTable } from "baresync/schema";
+
+export const syncOutbox = createSyncOutboxTable();
+export const syncCursors = createSyncCursorsTable();

package/dist/templates/sync-contract/src/local-synced-schema.ts

@@ -0,0 +1,22 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { localSyncColumns } from "baresync/schema";
+
+export const lists = sqliteTable("lists", {
+  id: text("id").primaryKey(),
+  scopeId: text("scope_id").notNull(),
+  name: text("name").notNull(),
+  description: text("description"),
+  ...localSyncColumns(),
+});
+
+export const todos = sqliteTable("todos", {
+  id: text("id").primaryKey(),
+  scopeId: text("scope_id").notNull(),
+  listId: text("list_id")
+    .notNull()
+    .references(() => lists.id, { onDelete: "cascade" }),
+  title: text("title").notNull(),
+  completed: integer("completed", { mode: "boolean" }).notNull().default(false),
+  notes: text("notes"),
+  ...localSyncColumns(),
+});

package/dist/templates/sync-contract/sync.config.ts

@@ -0,0 +1,17 @@
+import { defineSyncConfig } from "baresync/generator";
+import * as apiSyncedSchema from "./src/api-synced-schema";
+import * as localSyncedSchema from "./src/local-synced-schema";
+import { fileURLToPath } from "node:url";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+
+export const syncGeneratorConfig = defineSyncConfig({
+  apiSyncedSchema,
+  localSyncedSchema,
+  outputDir: "./generated",
+  schemaSourceDir: `${__dirname}src`,
+  tables: {
+    lists: { scopeColumn: "scope_id" },
+    todos: { scopeColumn: "scope_id" },
+  },
+});

package/dist/templates/sync-contract/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "../..",
+    "types": ["node"]
+  },
+  "include": ["src", "sync.config.ts"]
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "create-baresync",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Scaffold Baresync starter workspaces",
+  "license": "MIT",
+  "packageManager": "bun@1.3.13",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "create-baresync": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run src/build.ts",
+    "typecheck": "bun x tsc -p tsconfig.json --noEmit",
+    "test": "bun x vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.4.0",
+    "jsonrepair": "^3.14.0",
+    "picocolors": "1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "typescript": "5.9.2",
+    "vitest": "^4.1.6"
+  }
+}