@tinyrack/devsync 1.1.0 → 1.3.0

package/src/services/forget.ts

@@ -1,261 +0,0 @@
-import { readdir, rm } from "node:fs/promises";
-import { dirname, join, posix } from "node:path";
-
-import {
-  type ResolvedSyncConfig,
-  type ResolvedSyncConfigEntry,
-  readSyncConfig,
-  resolveSyncArtifactsDirectoryPath,
-} from "#app/config/sync.ts";
-
-import {
-  createSyncConfigDocument,
-  sortSyncConfigEntries,
-  writeValidatedSyncConfig,
-} from "./config-file.ts";
-import { DevsyncError } from "./error.ts";
-import {
-  getPathStats,
-  listDirectoryEntries,
-  removePathAtomically,
-} from "./filesystem.ts";
-import {
-  isExplicitLocalPath,
-  isPathEqualOrNested,
-  resolveCommandTargetPath,
-  tryNormalizeRepoPathInput,
-} from "./paths.ts";
-import {
-  isSecretArtifactPath,
-  resolveArtifactRelativePath,
-} from "./repo-artifacts.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncForgetRequest = Readonly<{
-  target: string;
-}>;
-
-export type SyncForgetResult = Readonly<{
-  configPath: string;
-  localPath: string;
-  plainArtifactCount: number;
-  repoPath: string;
-  secretArtifactCount: number;
-  syncDirectory: string;
-}>;
-
-const findMatchingTrackedEntry = (
-  config: ResolvedSyncConfig,
-  target: string,
-  context: Pick<SyncContext, "cwd" | "environment">,
-) => {
-  const trimmedTarget = target.trim();
-  const resolvedTargetPath = resolveCommandTargetPath(
-    trimmedTarget,
-    context.environment,
-    context.cwd,
-  );
-  const byLocalPath = config.entries.find((entry) => {
-    return entry.localPath === resolvedTargetPath;
-  });
-
-  if (byLocalPath !== undefined || isExplicitLocalPath(trimmedTarget)) {
-    return byLocalPath;
-  }
-
-  const normalizedRepoPath = tryNormalizeRepoPathInput(trimmedTarget);
-
-  if (normalizedRepoPath === undefined) {
-    return undefined;
-  }
-
-  return config.entries.find((entry) => {
-    return entry.repoPath === normalizedRepoPath;
-  });
-};
-
-const collectRepoArtifactCounts = async (
-  targetPath: string,
-  counts: {
-    plain: number;
-    secret: number;
-  },
-  relativePath: string,
-) => {
-  const stats = await getPathStats(targetPath);
-
-  if (stats === undefined) {
-    return;
-  }
-
-  if (stats.isDirectory()) {
-    counts.plain += 1;
-
-    const entries = await listDirectoryEntries(targetPath);
-
-    for (const entry of entries) {
-      await collectRepoArtifactCounts(
-        join(targetPath, entry.name),
-        counts,
-        posix.join(relativePath, entry.name),
-      );
-    }
-
-    return;
-  }
-
-  if (isSecretArtifactPath(relativePath)) {
-    counts.secret += 1;
-  } else {
-    counts.plain += 1;
-  }
-};
-
-const collectEntryArtifactCounts = async (
-  syncDirectory: string,
-  entry: ResolvedSyncConfigEntry,
-) => {
-  const artifactsRoot = resolveSyncArtifactsDirectoryPath(syncDirectory);
-  const counts = {
-    plain: 0,
-    secret: 0,
-  };
-
-  if (entry.kind === "directory") {
-    await collectRepoArtifactCounts(
-      join(artifactsRoot, ...entry.repoPath.split("/")),
-      counts,
-      entry.repoPath,
-    );
-  } else {
-    await collectRepoArtifactCounts(
-      join(artifactsRoot, ...entry.repoPath.split("/")),
-      counts,
-      entry.repoPath,
-    );
-    await collectRepoArtifactCounts(
-      join(
-        artifactsRoot,
-        ...resolveArtifactRelativePath({
-          category: "secret",
-          repoPath: entry.repoPath,
-        }).split("/"),
-      ),
-      counts,
-      resolveArtifactRelativePath({
-        category: "secret",
-        repoPath: entry.repoPath,
-      }),
-    );
-  }
-
-  return {
-    plainArtifactCount: counts.plain,
-    secretArtifactCount: counts.secret,
-  };
-};
-
-const pruneEmptyParentDirectories = async (
-  startPath: string,
-  rootPath: string,
-) => {
-  let currentPath = startPath;
-
-  while (
-    isPathEqualOrNested(currentPath, rootPath) &&
-    currentPath !== rootPath
-  ) {
-    const stats = await getPathStats(currentPath);
-
-    if (stats === undefined) {
-      currentPath = dirname(currentPath);
-      continue;
-    }
-
-    if (!stats.isDirectory()) {
-      break;
-    }
-
-    const entries = await readdir(currentPath);
-
-    if (entries.length > 0) {
-      break;
-    }
-
-    await rm(currentPath, { force: true, recursive: true });
-    currentPath = dirname(currentPath);
-  }
-};
-
-const removeTrackedEntryArtifacts = async (
-  syncDirectory: string,
-  entry: ResolvedSyncConfigEntry,
-) => {
-  const artifactsRoot = resolveSyncArtifactsDirectoryPath(syncDirectory);
-  const plainPath = join(artifactsRoot, ...entry.repoPath.split("/"));
-
-  await removePathAtomically(plainPath);
-  await pruneEmptyParentDirectories(dirname(plainPath), artifactsRoot);
-
-  if (entry.kind === "directory") {
-    return;
-  }
-
-  const secretPath = join(
-    artifactsRoot,
-    ...resolveArtifactRelativePath({
-      category: "secret",
-      repoPath: entry.repoPath,
-    }).split("/"),
-  );
-
-  await removePathAtomically(secretPath);
-  await pruneEmptyParentDirectories(dirname(secretPath), artifactsRoot);
-};
-
-export const forgetSyncTarget = async (
-  request: SyncForgetRequest,
-  context: SyncContext,
-): Promise<SyncForgetResult> => {
-  const target = request.target.trim();
-
-  if (target.length === 0) {
-    throw new DevsyncError("Target path is required.");
-  }
-
-  await ensureSyncRepository(context);
-
-  const config = await readSyncConfig(
-    context.paths.syncDirectory,
-    context.environment,
-  );
-  const entry = findMatchingTrackedEntry(config, target, context);
-
-  if (entry === undefined) {
-    throw new DevsyncError(`No tracked sync entry matches: ${target}`);
-  }
-
-  const { plainArtifactCount, secretArtifactCount } =
-    await collectEntryArtifactCounts(context.paths.syncDirectory, entry);
-  const nextConfig = createSyncConfigDocument(config);
-
-  nextConfig.entries = sortSyncConfigEntries(
-    nextConfig.entries.filter((configEntry) => {
-      return configEntry.repoPath !== entry.repoPath;
-    }),
-  );
-
-  await writeValidatedSyncConfig(context.paths.syncDirectory, nextConfig, {
-    environment: context.environment,
-  });
-  await removeTrackedEntryArtifacts(context.paths.syncDirectory, entry);
-
-  return {
-    configPath: context.paths.configPath,
-    localPath: entry.localPath,
-    plainArtifactCount,
-    repoPath: entry.repoPath,
-    secretArtifactCount,
-    syncDirectory: context.paths.syncDirectory,
-  };
-};

package/src/services/git.test.ts

@@ -1,83 +0,0 @@
-import { rm } from "node:fs/promises";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { DevsyncError } from "#app/services/error.ts";
-import {
-  ensureGitRepository,
-  ensureRepository,
-  initializeRepository,
-} from "#app/services/git.ts";
-import {
-  createTemporaryDirectory,
-  runGit,
-} from "../test/helpers/sync-fixture.ts";
-
-const temporaryDirectories: string[] = [];
-
-const createWorkspace = async () => {
-  const directory = await createTemporaryDirectory("devsync-git-");
-
-  temporaryDirectories.push(directory);
-
-  return directory;
-};
-
-afterEach(async () => {
-  while (temporaryDirectories.length > 0) {
-    const directory = temporaryDirectories.pop();
-
-    if (directory !== undefined) {
-      await rm(directory, { force: true, recursive: true });
-    }
-  }
-});
-
-describe("git helpers", () => {
-  it("initializes a repository with a main branch", async () => {
-    const workspace = await createWorkspace();
-    const repositoryPath = join(workspace, "sync");
-
-    await expect(initializeRepository(repositoryPath)).resolves.toEqual({
-      action: "initialized",
-    });
-    await expect(ensureRepository(repositoryPath)).resolves.toBeUndefined();
-    await expect(
-      runGit(["-C", repositoryPath, "symbolic-ref", "--short", "HEAD"]),
-    ).resolves.toMatchObject({
-      stdout: "main\n",
-    });
-  });
-
-  it("clones an existing repository and reports the source", async () => {
-    const workspace = await createWorkspace();
-    const sourcePath = join(workspace, "source");
-    const targetPath = join(workspace, "clone");
-
-    await runGit(["init", "-b", "main", sourcePath], workspace);
-
-    await expect(initializeRepository(targetPath, sourcePath)).resolves.toEqual(
-      {
-        action: "cloned",
-        source: sourcePath,
-      },
-    );
-    await expect(ensureRepository(targetPath)).resolves.toBeUndefined();
-  });
-
-  it("wraps missing git repositories in a DevsyncError", async () => {
-    const workspace = await createWorkspace();
-    const missingRepositoryPath = join(workspace, "not-a-repo");
-
-    await expect(
-      ensureRepository(missingRepositoryPath),
-    ).rejects.toThrowError();
-    await expect(
-      ensureGitRepository(missingRepositoryPath),
-    ).rejects.toThrowError(DevsyncError);
-    await expect(
-      ensureGitRepository(missingRepositoryPath),
-    ).rejects.toThrowError(/Sync directory is not a git repository/u);
-  });
-});

package/src/services/git.ts

@@ -1,74 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-import { DevsyncError } from "./error.ts";
-
-const execFileAsync = promisify(execFile);
-
-const runGitCommand = async (
-  args: readonly string[],
-  options?: Readonly<{ cwd?: string }>,
-) => {
-  try {
-    const result = await execFileAsync("git", [...args], {
-      cwd: options?.cwd,
-      encoding: "utf8",
-      maxBuffer: 10_000_000,
-    });
-
-    return {
-      stderr: result.stderr,
-      stdout: result.stdout,
-    };
-  } catch (error: unknown) {
-    if (error instanceof Error && "stderr" in error) {
-      const stderr =
-        typeof error.stderr === "string" ? error.stderr.trim() : undefined;
-      const stdout =
-        "stdout" in error && typeof error.stdout === "string"
-          ? error.stdout.trim()
-          : undefined;
-      const message = stderr || stdout || error.message;
-
-      throw new Error(message);
-    }
-
-    throw new Error(error instanceof Error ? error.message : "git failed.");
-  }
-};
-
-export const ensureRepository = async (directory: string) => {
-  await runGitCommand(["-C", directory, "rev-parse", "--is-inside-work-tree"]);
-};
-
-export const initializeRepository = async (
-  directory: string,
-  source?: string,
-) => {
-  if (source === undefined) {
-    await runGitCommand(["init", "-b", "main", directory]);
-
-    return {
-      action: "initialized" as const,
-    };
-  }
-
-  await runGitCommand(["clone", source, directory]);
-
-  return {
-    action: "cloned" as const,
-    source,
-  };
-};
-
-export const ensureGitRepository = async (syncDirectory: string) => {
-  try {
-    await ensureRepository(syncDirectory);
-  } catch (error: unknown) {
-    throw new DevsyncError(
-      error instanceof Error
-        ? `Sync directory is not a git repository: ${error.message}`
-        : "Sync directory is not a git repository.",
-    );
-  }
-};

package/src/services/init.test.ts

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