@tinyrack/devsync 1.0.0 → 1.1.0

package/src/services/init.test.ts

@@ -0,0 +1,109 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { DevsyncError } from "#app/services/error.ts";
+import { initializeSync } from "#app/services/init.ts";
+import { createSyncContext } from "#app/services/runtime.ts";
+import {
+  createAgeKeyPair,
+  createTemporaryDirectory,
+  runGit,
+  writeIdentityFile,
+} from "../test/helpers/sync-fixture.ts";
+
+const temporaryDirectories: string[] = [];
+
+const createWorkspace = async () => {
+  const directory = await createTemporaryDirectory("devsync-init-");
+
+  temporaryDirectories.push(directory);
+
+  return directory;
+};
+
+const createEnvironment = (
+  homeDirectory: string,
+  xdgConfigHome: string,
+): NodeJS.ProcessEnv => {
+  return {
+    HOME: homeDirectory,
+    XDG_CONFIG_HOME: xdgConfigHome,
+  };
+};
+
+afterEach(async () => {
+  while (temporaryDirectories.length > 0) {
+    const directory = temporaryDirectories.pop();
+
+    if (directory !== undefined) {
+      await rm(directory, { force: true, recursive: true });
+    }
+  }
+});
+
+describe("init service", () => {
+  it("clones a configured repository source during initialization", async () => {
+    const workspace = await createWorkspace();
+    const homeDirectory = join(workspace, "home");
+    const xdgConfigHome = join(workspace, "xdg");
+    const sourceRepository = join(workspace, "remote-sync");
+    const ageKeys = await createAgeKeyPair();
+
+    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
+    await runGit(["init", "-b", "main", sourceRepository], workspace);
+
+    const result = await initializeSync(
+      {
+        identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
+        recipients: [ageKeys.recipient],
+        repository: sourceRepository,
+      },
+      createSyncContext({
+        environment: createEnvironment(homeDirectory, xdgConfigHome),
+      }),
+    );
+
+    expect(result.gitAction).toBe("cloned");
+    expect(result.gitSource).toBe(sourceRepository);
+    expect(
+      await readFile(join(result.syncDirectory, "config.json"), "utf8"),
+    ).toContain("$XDG_CONFIG_HOME/devsync/age/keys.txt");
+  });
+
+  it("rejects non-empty sync directories that are not git repositories", async () => {
+    const workspace = await createWorkspace();
+    const homeDirectory = join(workspace, "home");
+    const xdgConfigHome = join(workspace, "xdg");
+    const syncDirectory = join(xdgConfigHome, "devsync", "sync");
+    const ageKeys = await createAgeKeyPair();
+
+    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
+    await mkdir(syncDirectory, { recursive: true });
+    await writeFile(join(syncDirectory, "placeholder.txt"), "keep\n", "utf8");
+
+    await expect(
+      initializeSync(
+        {
+          identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
+          recipients: [ageKeys.recipient],
+        },
+        createSyncContext({
+          environment: createEnvironment(homeDirectory, xdgConfigHome),
+        }),
+      ),
+    ).rejects.toThrowError(DevsyncError);
+    await expect(
+      initializeSync(
+        {
+          identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
+          recipients: [ageKeys.recipient],
+        },
+        createSyncContext({
+          environment: createEnvironment(homeDirectory, xdgConfigHome),
+        }),
+      ),
+    ).rejects.toThrowError(/already exists and is not empty/u);
+  });
+});

package/src/services/list.ts

@@ -0,0 +1,63 @@
+import {
+  formatSyncOverrideSelector,
+  readSyncConfig,
+  type SyncMode,
+} from "#app/config/sync.ts";
+
+import { countConfiguredRules } from "./config-file.ts";
+import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
+
+export type SyncListOverride = Readonly<{
+  mode: SyncMode;
+  selector: string;
+}>;
+
+export type SyncListEntry = Readonly<{
+  kind: "directory" | "file";
+  localPath: string;
+  mode: SyncMode;
+  name: string;
+  overrides: readonly SyncListOverride[];
+  repoPath: string;
+}>;
+
+export type SyncListResult = Readonly<{
+  configPath: string;
+  entries: readonly SyncListEntry[];
+  recipientCount: number;
+  ruleCount: number;
+  syncDirectory: string;
+}>;
+
+export const listSyncConfig = async (
+  context: SyncContext,
+): Promise<SyncListResult> => {
+  await ensureSyncRepository(context);
+
+  const config = await readSyncConfig(
+    context.paths.syncDirectory,
+    context.environment,
+  );
+
+  return {
+    configPath: context.paths.configPath,
+    entries: config.entries.map((entry) => {
+      return {
+        kind: entry.kind,
+        localPath: entry.localPath,
+        mode: entry.mode,
+        name: entry.name,
+        overrides: entry.overrides.map((override) => {
+          return {
+            mode: override.mode,
+            selector: formatSyncOverrideSelector(override),
+          };
+        }),
+        repoPath: entry.repoPath,
+      };
+    }),
+    recipientCount: config.age.recipients.length,
+    ruleCount: countConfiguredRules(config),
+    syncDirectory: context.paths.syncDirectory,
+  };
+};

package/src/services/local-materialization.ts

@@ -316,8 +316,8 @@ export const countDeletedLocalNodes = async (
   entry: ResolvedSyncConfigEntry,
   desiredKeys: ReadonlySet<string>,
   config: ResolvedSyncConfig,
+  existingKeys: Set<string> = new Set<string>(),
 ) => {
-  const existingKeys = new Set<string>();
   const preservedIgnoredKeys = new Set<string>();
 
   await collectLocalLeafKeys(entry.localPath, entry.repoPath, existingKeys);

package/src/services/paths.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+
+import { DevsyncError } from "#app/services/error.ts";
+import {
+  buildConfiguredHomeLocalPath,
+  buildDirectoryKey,
+  buildRepoPathWithinRoot,
+  doPathsOverlap,
+  isExplicitLocalPath,
+  isPathEqualOrNested,
+  resolveCommandTargetPath,
+  tryBuildRepoPathWithinRoot,
+  tryNormalizeRepoPathInput,
+} from "#app/services/paths.ts";
+
+describe("path helpers", () => {
+  it("builds repository directory keys", () => {
+    expect(buildDirectoryKey("bundle/cache")).toBe("bundle/cache/");
+  });
+
+  it("detects nested and overlapping paths", () => {
+    expect(isPathEqualOrNested("/tmp/home/project/file.txt", "/tmp/home")).toBe(
+      true,
+    );
+    expect(isPathEqualOrNested("/tmp/elsewhere", "/tmp/home")).toBe(false);
+    expect(doPathsOverlap("/tmp/home/project", "/tmp/home")).toBe(true);
+    expect(doPathsOverlap("/tmp/home/one", "/tmp/home/two")).toBe(false);
+  });
+
+  it("recognizes explicit local path inputs", () => {
+    expect(isExplicitLocalPath(".")).toBe(true);
+    expect(isExplicitLocalPath("~/bundle")).toBe(true);
+    expect(isExplicitLocalPath("../bundle")).toBe(true);
+    expect(isExplicitLocalPath("bundle/file.txt")).toBe(false);
+  });
+
+  it("resolves command targets from cwd and home prefixes", () => {
+    expect(
+      resolveCommandTargetPath("~/bundle", { HOME: "/tmp/home" }, "/tmp/cwd"),
+    ).toBe("/tmp/home/bundle");
+    expect(
+      resolveCommandTargetPath("./bundle", { HOME: "/tmp/home" }, "/tmp/cwd"),
+    ).toBe("/tmp/cwd/bundle");
+  });
+
+  it("builds repository paths within a root", () => {
+    expect(
+      buildRepoPathWithinRoot(
+        "/tmp/home/.config/tool/settings.json",
+        "/tmp/home",
+        "Sync target",
+      ),
+    ).toBe(".config/tool/settings.json");
+    expect(buildConfiguredHomeLocalPath(".config/tool/settings.json")).toBe(
+      "~/.config/tool/settings.json",
+    );
+  });
+
+  it("rejects root and out-of-root repository paths", () => {
+    expect(() => {
+      buildRepoPathWithinRoot("/tmp/home", "/tmp/home", "Sync target");
+    }).toThrowError(DevsyncError);
+    expect(() => {
+      buildRepoPathWithinRoot("/tmp/elsewhere", "/tmp/home", "Sync target");
+    }).toThrowError(DevsyncError);
+  });
+
+  it("returns undefined from tolerant helpers for invalid inputs", () => {
+    expect(
+      tryBuildRepoPathWithinRoot("/tmp/elsewhere", "/tmp/home", "Sync target"),
+    ).toBeUndefined();
+    expect(tryNormalizeRepoPathInput("../bundle")).toBeUndefined();
+  });
+});

package/src/services/pull.ts

@@ -1,4 +1,4 @@
-import { readSyncConfig } from "#app/config/sync.ts";
+import { type ResolvedSyncConfig, readSyncConfig } from "#app/config/sync.ts";
 
 import {
   applyEntryMaterialization,
@@ -24,16 +24,32 @@ export type SyncPullResult = Readonly<{
   syncDirectory: string;
 }>;
 
-export const pullSync = async (
-  request: SyncPullRequest,
-  context: SyncContext,
-): Promise<SyncPullResult> => {
-  await ensureSyncRepository(context);
+export type PullPlan = Readonly<{
+  counts: ReturnType<typeof buildPullCounts>;
+  deletedLocalCount: number;
+  desiredKeys: ReadonlySet<string>;
+  existingKeys: ReadonlySet<string>;
+  materializations: readonly ReturnType<typeof buildEntryMaterialization>[];
+}>;
 
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
+const collectDesiredKeys = (
+  materializations: readonly ReturnType<typeof buildEntryMaterialization>[],
+) => {
+  const keys = new Set<string>();
+
+  for (const materialization of materializations) {
+    for (const key of materialization.desiredKeys) {
+      keys.add(key);
+    }
+  }
+
+  return keys;
+};
+
+export const buildPullPlan = async (
+  config: ResolvedSyncConfig,
+  context: SyncContext,
+): Promise<PullPlan> => {
   const snapshot = await buildRepositorySnapshot(
     context.paths.syncDirectory,
     config,
@@ -43,6 +59,7 @@ export const pullSync = async (
   });
 
   let deletedLocalCount = 0;
+  const existingKeys = new Set<string>();
 
   for (let index = 0; index < config.entries.length; index += 1) {
     const entry = config.entries[index];
@@ -56,20 +73,72 @@ export const pullSync = async (
       entry,
       materialization.desiredKeys,
       config,
+      existingKeys,
     );
-
-    if (!request.dryRun) {
-      await applyEntryMaterialization(entry, materialization, config);
-    }
   }
 
-  const counts = buildPullCounts(materializations);
+  return {
+    counts: buildPullCounts(materializations),
+    deletedLocalCount,
+    desiredKeys: collectDesiredKeys(materializations),
+    existingKeys,
+    materializations,
+  };
+};
 
+export const buildPullPlanPreview = (plan: PullPlan) => {
+  const desired = [...plan.desiredKeys].sort((left, right) => {
+    return left.localeCompare(right);
+  });
+  const deleted = [...plan.existingKeys]
+    .filter((key) => {
+      return !plan.desiredKeys.has(key);
+    })
+    .sort((left, right) => {
+      return left.localeCompare(right);
+    });
+
+  return [...desired.slice(0, 4), ...deleted.slice(0, 4)].slice(0, 6);
+};
+
+export const buildPullResultFromPlan = (
+  plan: PullPlan,
+  context: SyncContext,
+  dryRun: boolean,
+): SyncPullResult => {
   return {
     configPath: context.paths.configPath,
-    deletedLocalCount,
-    dryRun: request.dryRun,
+    deletedLocalCount: plan.deletedLocalCount,
+    dryRun,
     syncDirectory: context.paths.syncDirectory,
-    ...counts,
+    ...plan.counts,
   };
 };
+
+export const pullSync = async (
+  request: SyncPullRequest,
+  context: SyncContext,
+): Promise<SyncPullResult> => {
+  await ensureSyncRepository(context);
+
+  const config = await readSyncConfig(
+    context.paths.syncDirectory,
+    context.environment,
+  );
+  const plan = await buildPullPlan(config, context);
+
+  for (let index = 0; index < config.entries.length; index += 1) {
+    const entry = config.entries[index];
+    const materialization = plan.materializations[index];
+
+    if (entry === undefined || materialization === undefined) {
+      continue;
+    }
+
+    if (!request.dryRun) {
+      await applyEntryMaterialization(entry, materialization, config);
+    }
+  }
+
+  return buildPullResultFromPlan(plan, context, request.dryRun);
+};

package/src/services/push.ts

@@ -2,6 +2,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
 
 import {
+  type ResolvedSyncConfig,
   readSyncConfig,
   resolveSyncArtifactsDirectoryPath,
 } from "#app/config/sync.ts";
@@ -31,6 +32,14 @@ export type SyncPushResult = Readonly<{
   syncDirectory: string;
 }>;
 
+export type PushPlan = Readonly<{
+  counts: ReturnType<typeof buildPushCounts>;
+  deletedArtifactCount: number;
+  desiredArtifactKeys: ReadonlySet<string>;
+  existingArtifactKeys: ReadonlySet<string>;
+  snapshot: ReadonlyMap<string, SnapshotNode>;
+}>;
+
 const buildPushCounts = (snapshot: ReadonlyMap<string, SnapshotNode>) => {
   let directoryCount = 0;
   let encryptedFileCount = 0;
@@ -63,16 +72,10 @@ const buildPushCounts = (snapshot: ReadonlyMap<string, SnapshotNode>) => {
   };
 };
 
-export const pushSync = async (
-  request: SyncPushRequest,
+export const buildPushPlan = async (
+  config: ResolvedSyncConfig,
   context: SyncContext,
-): Promise<SyncPushResult> => {
-  await ensureSyncRepository(context);
-
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
+): Promise<PushPlan> => {
   const snapshot = await buildLocalSnapshot(config);
   const artifacts = await buildRepoArtifacts(snapshot, config);
   const desiredArtifactKeys = new Set(
@@ -88,6 +91,56 @@ export const pushSync = async (
     return !desiredArtifactKeys.has(key);
   }).length;
 
+  return {
+    counts: buildPushCounts(snapshot),
+    deletedArtifactCount,
+    desiredArtifactKeys,
+    existingArtifactKeys,
+    snapshot,
+  };
+};
+
+export const buildPushPlanPreview = (plan: PushPlan) => {
+  const createdOrUpdated = [...plan.snapshot.keys()].sort((left, right) => {
+    return left.localeCompare(right);
+  });
+  const deleted = [...plan.existingArtifactKeys]
+    .filter((key) => {
+      return !plan.desiredArtifactKeys.has(key);
+    })
+    .sort((left, right) => {
+      return left.localeCompare(right);
+    });
+
+  return [...createdOrUpdated.slice(0, 4), ...deleted.slice(0, 4)].slice(0, 6);
+};
+
+export const buildPushResultFromPlan = (
+  plan: PushPlan,
+  context: SyncContext,
+  dryRun: boolean,
+): SyncPushResult => {
+  return {
+    configPath: context.paths.configPath,
+    deletedArtifactCount: plan.deletedArtifactCount,
+    dryRun,
+    syncDirectory: context.paths.syncDirectory,
+    ...plan.counts,
+  };
+};
+
+export const pushSync = async (
+  request: SyncPushRequest,
+  context: SyncContext,
+): Promise<SyncPushResult> => {
+  await ensureSyncRepository(context);
+
+  const config = await readSyncConfig(
+    context.paths.syncDirectory,
+    context.environment,
+  );
+  const plan = await buildPushPlan(config, context);
+
   if (!request.dryRun) {
     const stagingRoot = await mkdtemp(
       join(context.paths.syncDirectory, ".devsync-sync-push-"),
@@ -95,6 +148,8 @@ export const pushSync = async (
     const nextArtifactsDirectory = join(stagingRoot, "files");
 
     try {
+      const artifacts = await buildRepoArtifacts(plan.snapshot, config);
+
       await writeArtifactsToDirectory(nextArtifactsDirectory, artifacts);
 
       await replacePathAtomically(
@@ -109,13 +164,5 @@ export const pushSync = async (
     }
   }
 
-  const counts = buildPushCounts(snapshot);
-
-  return {
-    configPath: context.paths.configPath,
-    deletedArtifactCount,
-    dryRun: request.dryRun,
-    syncDirectory: context.paths.syncDirectory,
-    ...counts,
-  };
+  return buildPushResultFromPlan(plan, context, request.dryRun);
 };

package/src/services/status.ts

@@ -0,0 +1,57 @@
+import { readSyncConfig } from "#app/config/sync.ts";
+
+import { countConfiguredRules } from "./config-file.ts";
+import {
+  buildPullPlan,
+  buildPullPlanPreview,
+  buildPullResultFromPlan,
+} from "./pull.ts";
+import {
+  buildPushPlan,
+  buildPushPlanPreview,
+  buildPushResultFromPlan,
+} from "./push.ts";
+import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
+
+export type SyncStatusResult = Readonly<{
+  configPath: string;
+  entryCount: number;
+  pull: ReturnType<typeof buildPullResultFromPlan> & {
+    preview: readonly string[];
+  };
+  push: ReturnType<typeof buildPushResultFromPlan> & {
+    preview: readonly string[];
+  };
+  recipientCount: number;
+  ruleCount: number;
+  syncDirectory: string;
+}>;
+
+export const getSyncStatus = async (
+  context: SyncContext,
+): Promise<SyncStatusResult> => {
+  await ensureSyncRepository(context);
+
+  const config = await readSyncConfig(
+    context.paths.syncDirectory,
+    context.environment,
+  );
+  const pushPlan = await buildPushPlan(config, context);
+  const pullPlan = await buildPullPlan(config, context);
+
+  return {
+    configPath: context.paths.configPath,
+    entryCount: config.entries.length,
+    pull: {
+      ...buildPullResultFromPlan(pullPlan, context, true),
+      preview: buildPullPlanPreview(pullPlan),
+    },
+    push: {
+      ...buildPushResultFromPlan(pushPlan, context, true),
+      preview: buildPushPlanPreview(pushPlan),
+    },
+    recipientCount: config.age.recipients.length,
+    ruleCount: countConfiguredRules(config),
+    syncDirectory: context.paths.syncDirectory,
+  };
+};