@tinyrack/devsync 1.1.0 → 1.2.2

package/src/services/set.ts

@@ -1,383 +0,0 @@
-import { join } from "node:path";
-
-import {
-  findOwningSyncEntry,
-  type ResolvedSyncConfigEntry,
-  type ResolvedSyncOverride,
-  readSyncConfig,
-  resolveEntryRelativeRepoPath,
-  resolveRelativeSyncMode,
-  type SyncMode,
-} from "#app/config/sync.ts";
-
-import {
-  createSyncConfigDocument,
-  createSyncConfigDocumentEntry,
-  sortSyncConfigEntries,
-  writeValidatedSyncConfig,
-} from "./config-file.ts";
-import { DevsyncError } from "./error.ts";
-import { getPathStats } from "./filesystem.ts";
-import {
-  buildRepoPathWithinRoot,
-  isExplicitLocalPath,
-  resolveCommandTargetPath,
-  tryBuildRepoPathWithinRoot,
-  tryNormalizeRepoPathInput,
-} from "./paths.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncSetRequest = Readonly<{
-  recursive: boolean;
-  state: SyncMode;
-  target: string;
-}>;
-
-type SyncSetScope = "default" | "exact" | "subtree";
-type SyncSetAction = "added" | "removed" | "unchanged" | "updated";
-
-export type SyncSetResult = Readonly<{
-  action: SyncSetAction;
-  configPath: string;
-  entryRepoPath: string;
-  localPath: string;
-  mode: SyncMode;
-  repoPath: string;
-  scope: SyncSetScope;
-  syncDirectory: string;
-}>;
-
-const resolveTargetPath = async (
-  target: string,
-  entry: ResolvedSyncConfigEntry,
-  context: Pick<SyncContext, "cwd" | "environment" | "paths">,
-) => {
-  if (isExplicitLocalPath(target)) {
-    const localPath = resolveCommandTargetPath(
-      target,
-      context.environment,
-      context.cwd,
-    );
-    const stats = await getPathStats(localPath);
-
-    if (stats === undefined) {
-      throw new DevsyncError(`Sync set target does not exist: ${localPath}`);
-    }
-
-    return {
-      localPath,
-      repoPath: buildRepoPathWithinRoot(
-        localPath,
-        context.paths.homeDirectory,
-        "Sync set target",
-      ),
-      stats,
-    };
-  }
-
-  const repoPath = tryNormalizeRepoPathInput(target);
-
-  if (repoPath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be a local path or repository path: ${target}`,
-    );
-  }
-
-  const relativePath = resolveEntryRelativeRepoPath(entry, repoPath);
-  const localPath =
-    relativePath === undefined || relativePath === ""
-      ? entry.localPath
-      : join(entry.localPath, ...relativePath.split("/"));
-
-  return {
-    localPath,
-    repoPath,
-    stats: await getPathStats(localPath),
-  };
-};
-
-const resolveSetTarget = async (
-  target: string,
-  config: Awaited<ReturnType<typeof readSyncConfig>>,
-  context: Pick<SyncContext, "cwd" | "environment" | "paths">,
-) => {
-  const trimmedTarget = target.trim();
-
-  if (trimmedTarget.length === 0) {
-    throw new DevsyncError("Target path is required.");
-  }
-
-  const homeDirectory = context.paths.homeDirectory;
-  const explicitLocalPath = isExplicitLocalPath(trimmedTarget);
-  const localTargetPath = resolveCommandTargetPath(
-    trimmedTarget,
-    context.environment,
-    context.cwd,
-  );
-  const localRepoPath = explicitLocalPath
-    ? buildRepoPathWithinRoot(localTargetPath, homeDirectory, "Sync set target")
-    : tryBuildRepoPathWithinRoot(
-        localTargetPath,
-        homeDirectory,
-        "Sync set target",
-      );
-
-  if (localRepoPath !== undefined) {
-    const localStats = await getPathStats(localTargetPath);
-
-    if (explicitLocalPath && localStats === undefined) {
-      throw new DevsyncError(
-        `Sync set target does not exist: ${localTargetPath}`,
-      );
-    }
-
-    const entry = findOwningSyncEntry(config, localRepoPath);
-
-    if (entry?.kind === "directory") {
-      const relativePath = resolveEntryRelativeRepoPath(entry, localRepoPath);
-
-      if (relativePath !== undefined) {
-        return {
-          entry,
-          localPath: localTargetPath,
-          relativePath,
-          repoPath: localRepoPath,
-          stats: localStats,
-        };
-      }
-    }
-
-    if (explicitLocalPath) {
-      throw new DevsyncError(
-        `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-      );
-    }
-  }
-
-  const repoPath = tryNormalizeRepoPathInput(trimmedTarget);
-
-  if (repoPath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be a local path or repository path: ${trimmedTarget}`,
-    );
-  }
-
-  const entry = findOwningSyncEntry(config, repoPath);
-
-  if (entry === undefined || entry.kind !== "directory") {
-    throw new DevsyncError(
-      `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-    );
-  }
-
-  const resolvedTarget = await resolveTargetPath(trimmedTarget, entry, context);
-  const relativePath = resolveEntryRelativeRepoPath(
-    entry,
-    resolvedTarget.repoPath,
-  );
-
-  if (relativePath === undefined) {
-    throw new DevsyncError(
-      `Sync set target must be inside a tracked directory entry: ${trimmedTarget}`,
-    );
-  }
-
-  return {
-    entry,
-    localPath: resolvedTarget.localPath,
-    relativePath,
-    repoPath: resolvedTarget.repoPath,
-    stats: resolvedTarget.stats,
-  };
-};
-
-const updateEntryMode = (
-  entry: ResolvedSyncConfigEntry,
-  mode: SyncMode,
-): {
-  action: SyncSetAction;
-  entry: ResolvedSyncConfigEntry;
-} => {
-  if (entry.mode === mode) {
-    return {
-      action: "unchanged",
-      entry,
-    };
-  }
-
-  return {
-    action: "updated",
-    entry: {
-      ...entry,
-      mode,
-    },
-  };
-};
-
-const updateChildOverride = (
-  entry: ResolvedSyncConfigEntry,
-  input: Readonly<{
-    match: Extract<SyncSetScope, "exact" | "subtree">;
-    mode: SyncMode;
-    relativePath: string;
-  }>,
-): {
-  action: SyncSetAction;
-  entry: ResolvedSyncConfigEntry;
-} => {
-  const existingOverride = entry.overrides.find((override) => {
-    return (
-      override.match === input.match && override.path === input.relativePath
-    );
-  });
-  const remainingOverrides = entry.overrides.filter((override) => {
-    return !(
-      override.match === input.match && override.path === input.relativePath
-    );
-  });
-  const inheritedMode = resolveRelativeSyncMode(
-    entry.mode,
-    remainingOverrides,
-    input.relativePath,
-  );
-
-  if (input.mode === inheritedMode) {
-    if (existingOverride === undefined) {
-      return {
-        action: "unchanged",
-        entry,
-      };
-    }
-
-    return {
-      action: "removed",
-      entry: {
-        ...entry,
-        overrides: remainingOverrides,
-      },
-    };
-  }
-
-  if (existingOverride?.mode === input.mode) {
-    return {
-      action: "unchanged",
-      entry,
-    };
-  }
-
-  const nextOverride = {
-    match: input.match,
-    mode: input.mode,
-    path: input.relativePath,
-  } satisfies ResolvedSyncOverride;
-
-  return {
-    action: existingOverride === undefined ? "added" : "updated",
-    entry: {
-      ...entry,
-      overrides: [...remainingOverrides, nextOverride],
-    },
-  };
-};
-
-export const setSyncTargetMode = async (
-  request: SyncSetRequest,
-  context: SyncContext,
-): Promise<SyncSetResult> => {
-  await ensureSyncRepository(context);
-
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
-  const target = await resolveSetTarget(request.target, config, context);
-
-  if (target.relativePath === "") {
-    if (!request.recursive) {
-      throw new DevsyncError(
-        "Tracked directory roots require --recursive to update the entry mode.",
-      );
-    }
-
-    const update = updateEntryMode(target.entry, request.state);
-    const nextConfig = createSyncConfigDocument(config);
-
-    nextConfig.entries = sortSyncConfigEntries(
-      nextConfig.entries.map((entry) => {
-        if (entry.repoPath !== target.entry.repoPath) {
-          return entry;
-        }
-
-        return createSyncConfigDocumentEntry(update.entry);
-      }),
-    );
-
-    if (update.action !== "unchanged") {
-      await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-        environment: context.environment,
-      });
-    }
-
-    return {
-      action: update.action,
-      configPath: context.paths.configPath,
-      entryRepoPath: target.entry.repoPath,
-      localPath: target.localPath,
-      mode: request.state,
-      repoPath: target.repoPath,
-      scope: "default",
-      syncDirectory: context.paths.syncDirectory,
-    };
-  }
-
-  if (target.stats?.isDirectory() && !request.recursive) {
-    throw new DevsyncError(
-      "Directory targets require --recursive. Use a file path for exact overrides.",
-    );
-  }
-
-  if (
-    request.recursive &&
-    target.stats !== undefined &&
-    !target.stats.isDirectory()
-  ) {
-    throw new DevsyncError(
-      "--recursive can only be used with directories or tracked directory roots.",
-    );
-  }
-
-  const scope = request.recursive ? "subtree" : "exact";
-  const update = updateChildOverride(target.entry, {
-    match: scope,
-    mode: request.state,
-    relativePath: target.relativePath,
-  });
-  const nextConfig = createSyncConfigDocument(config);
-
-  nextConfig.entries = sortSyncConfigEntries(
-    nextConfig.entries.map((entry) => {
-      if (entry.repoPath !== target.entry.repoPath) {
-        return entry;
-      }
-
-      return createSyncConfigDocumentEntry(update.entry);
-    }),
-  );
-
-  if (update.action !== "unchanged") {
-    await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-      environment: context.environment,
-    });
-  }
-
-  return {
-    action: update.action,
-    configPath: context.paths.configPath,
-    entryRepoPath: target.entry.repoPath,
-    localPath: target.localPath,
-    mode: request.state,
-    repoPath: target.repoPath,
-    scope,
-    syncDirectory: context.paths.syncDirectory,
-  };
-};

package/src/services/status.ts

@@ -1,57 +0,0 @@
-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,
-  };
-};

package/src/services/sync.dry-run.test.ts

@@ -1,179 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { syncSecretArtifactSuffix } from "#app/config/sync.ts";
-import { addSyncTarget } from "#app/services/add.ts";
-import { initializeSync } from "#app/services/init.ts";
-import { pullSync } from "#app/services/pull.ts";
-import { pushSync } from "#app/services/push.ts";
-import { createSyncContext } from "#app/services/runtime.ts";
-import { setSyncTargetMode } from "#app/services/set.ts";
-import {
-  createAgeKeyPair,
-  createTemporaryDirectory,
-  writeIdentityFile,
-} from "../test/helpers/sync-fixture.ts";
-
-const temporaryDirectories: string[] = [];
-
-const createWorkspace = async () => {
-  const directory = await createTemporaryDirectory("devsync-dry-run-");
-
-  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("sync dry runs", () => {
-  it("reports push changes without mutating repository artifacts", async () => {
-    const workspace = await createWorkspace();
-    const homeDirectory = join(workspace, "home");
-    const xdgConfigHome = join(workspace, "xdg");
-    const bundleDirectory = join(homeDirectory, "bundle");
-    const plainFile = join(bundleDirectory, "plain.txt");
-    const secretFile = join(bundleDirectory, "token.txt");
-    const ageKeys = await createAgeKeyPair();
-    const context = createSyncContext({
-      environment: createEnvironment(homeDirectory, xdgConfigHome),
-    });
-
-    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
-    await mkdir(bundleDirectory, { recursive: true });
-    await writeFile(plainFile, "plain\n", "utf8");
-    await writeFile(secretFile, "secret\n", "utf8");
-
-    await initializeSync(
-      {
-        identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
-        recipients: [ageKeys.recipient],
-      },
-      context,
-    );
-    await addSyncTarget(
-      {
-        secret: false,
-        target: bundleDirectory,
-      },
-      context,
-    );
-    await setSyncTargetMode(
-      {
-        recursive: false,
-        state: "secret",
-        target: secretFile,
-      },
-      context,
-    );
-
-    const result = await pushSync(
-      {
-        dryRun: true,
-      },
-      context,
-    );
-
-    expect(result.dryRun).toBe(true);
-    expect(result.directoryCount).toBe(1);
-    expect(result.plainFileCount).toBe(1);
-    expect(result.encryptedFileCount).toBe(1);
-    await expect(
-      readFile(
-        join(xdgConfigHome, "devsync", "sync", "files", "bundle", "plain.txt"),
-        "utf8",
-      ),
-    ).rejects.toMatchObject({
-      code: "ENOENT",
-    });
-    await expect(
-      readFile(
-        join(
-          xdgConfigHome,
-          "devsync",
-          "sync",
-          "files",
-          "bundle",
-          `token.txt${syncSecretArtifactSuffix}`,
-        ),
-        "utf8",
-      ),
-    ).rejects.toMatchObject({
-      code: "ENOENT",
-    });
-  });
-
-  it("reports pull changes without mutating local files", async () => {
-    const workspace = await createWorkspace();
-    const homeDirectory = join(workspace, "home");
-    const xdgConfigHome = join(workspace, "xdg");
-    const bundleDirectory = join(homeDirectory, "bundle");
-    const plainFile = join(bundleDirectory, "plain.txt");
-    const extraFile = join(bundleDirectory, "extra.txt");
-    const ageKeys = await createAgeKeyPair();
-    const context = createSyncContext({
-      environment: createEnvironment(homeDirectory, xdgConfigHome),
-    });
-
-    await writeIdentityFile(xdgConfigHome, ageKeys.identity);
-    await mkdir(bundleDirectory, { recursive: true });
-    await writeFile(plainFile, "plain\n", "utf8");
-
-    await initializeSync(
-      {
-        identityFile: "$XDG_CONFIG_HOME/devsync/age/keys.txt",
-        recipients: [ageKeys.recipient],
-      },
-      context,
-    );
-    await addSyncTarget(
-      {
-        secret: false,
-        target: bundleDirectory,
-      },
-      context,
-    );
-    await pushSync(
-      {
-        dryRun: false,
-      },
-      context,
-    );
-
-    await writeFile(plainFile, "changed locally\n", "utf8");
-    await writeFile(extraFile, "leave me\n", "utf8");
-
-    const result = await pullSync(
-      {
-        dryRun: true,
-      },
-      context,
-    );
-
-    expect(result.dryRun).toBe(true);
-    expect(result.plainFileCount).toBe(1);
-    expect(result.deletedLocalCount).toBeGreaterThanOrEqual(1);
-    expect(await readFile(plainFile, "utf8")).toBe("changed locally\n");
-    expect(await readFile(extraFile, "utf8")).toBe("leave me\n");
-  });
-});