@tinyrack/devsync 1.0.3 → 1.2.2

package/src/services/error.ts

@@ -1,6 +0,0 @@
-export class DevsyncError extends Error {
-  public constructor(message: string) {
-    super(message);
-    this.name = "DevsyncError";
-  }
-}

package/src/services/filesystem.test.ts

@@ -1,171 +0,0 @@
-import {
-  chmod,
-  lstat,
-  mkdir,
-  readFile,
-  readlink,
-  rm,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  buildExecutableMode,
-  copyFilesystemNode,
-  getPathStats,
-  isExecutableMode,
-  listDirectoryEntries,
-  pathExists,
-  removePathAtomically,
-  replacePathAtomically,
-  writeFileNode,
-  writeSymlinkNode,
-  writeTextFileAtomically,
-} from "#app/services/filesystem.ts";
-import { createTemporaryDirectory } from "../test/helpers/sync-fixture.ts";
-
-const temporaryDirectories: string[] = [];
-
-const createWorkspace = async () => {
-  const directory = await createTemporaryDirectory("devsync-filesystem-");
-
-  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("filesystem helpers", () => {
-  it("checks path existence and missing stats", async () => {
-    const workspace = await createWorkspace();
-    const filePath = join(workspace, "value.txt");
-
-    expect(await pathExists(filePath)).toBe(false);
-    expect(await getPathStats(filePath)).toBeUndefined();
-
-    await writeFile(filePath, "value\n", "utf8");
-
-    expect(await pathExists(filePath)).toBe(true);
-    expect((await getPathStats(filePath))?.isFile()).toBe(true);
-  });
-
-  it("lists directory entries in sorted order", async () => {
-    const workspace = await createWorkspace();
-
-    await mkdir(join(workspace, "b"), { recursive: true });
-    await writeFile(join(workspace, "c.txt"), "c\n", "utf8");
-    await writeFile(join(workspace, "a.txt"), "a\n", "utf8");
-
-    const entries = await listDirectoryEntries(workspace);
-
-    expect(entries.map((entry) => entry.name)).toEqual(["a.txt", "b", "c.txt"]);
-  });
-
-  it("builds and detects executable modes", async () => {
-    expect(buildExecutableMode(true)).toBe(0o755);
-    expect(buildExecutableMode(false)).toBe(0o644);
-    expect(isExecutableMode(0o100755)).toBe(true);
-    expect(isExecutableMode(0o100644)).toBe(false);
-  });
-
-  it("writes regular files and preserves executable bits", async () => {
-    if (process.platform === "win32") {
-      return;
-    }
-
-    const workspace = await createWorkspace();
-    const filePath = join(workspace, "bin", "tool.sh");
-
-    await writeFileNode(filePath, {
-      contents: "#!/bin/sh\nexit 0\n",
-      executable: true,
-    });
-
-    expect(await readFile(filePath, "utf8")).toContain("#!/bin/sh");
-    expect(isExecutableMode((await lstat(filePath)).mode)).toBe(true);
-  });
-
-  it("writes symlinks after removing existing content", async () => {
-    if (process.platform === "win32") {
-      return;
-    }
-
-    const workspace = await createWorkspace();
-    const linkPath = join(workspace, "links", "current");
-
-    await mkdir(join(workspace, "links"), { recursive: true });
-    await writeFile(linkPath, "old\n", "utf8");
-    await writeSymlinkNode(linkPath, "../target.txt");
-
-    expect(await readlink(linkPath)).toBe("../target.txt");
-  });
-
-  it("copies regular files and symlinks", async () => {
-    if (process.platform === "win32") {
-      return;
-    }
-
-    const workspace = await createWorkspace();
-    const sourceDirectory = join(workspace, "source");
-    const targetDirectory = join(workspace, "target");
-    const filePath = join(sourceDirectory, "nested", "value.txt");
-    const linkPath = join(sourceDirectory, "nested", "value-link");
-
-    await mkdir(join(sourceDirectory, "nested"), { recursive: true });
-    await writeFile(filePath, "payload\n", "utf8");
-    await chmod(filePath, 0o755);
-    await symlink("value.txt", linkPath);
-
-    await copyFilesystemNode(sourceDirectory, targetDirectory);
-
-    expect(
-      await readFile(join(targetDirectory, "nested", "value.txt"), "utf8"),
-    ).toBe("payload\n");
-    expect(await readlink(join(targetDirectory, "nested", "value-link"))).toBe(
-      "value.txt",
-    );
-  });
-
-  it("replaces and removes paths atomically", async () => {
-    const workspace = await createWorkspace();
-    const targetPath = join(workspace, "config.json");
-    const stagedPath = join(workspace, "next.json");
-
-    await writeFile(targetPath, "old\n", "utf8");
-    await writeFile(stagedPath, "new\n", "utf8");
-
-    await replacePathAtomically(targetPath, stagedPath);
-
-    expect(await readFile(targetPath, "utf8")).toBe("new\n");
-    expect(await pathExists(stagedPath)).toBe(false);
-
-    await removePathAtomically(targetPath);
-
-    expect(await pathExists(targetPath)).toBe(false);
-    await removePathAtomically(targetPath);
-    expect(await pathExists(targetPath)).toBe(false);
-  });
-
-  it("writes text files atomically for create and overwrite flows", async () => {
-    const workspace = await createWorkspace();
-    const targetPath = join(workspace, "nested", "config.json");
-
-    await writeTextFileAtomically(targetPath, "first\n");
-    expect(await readFile(targetPath, "utf8")).toBe("first\n");
-
-    await writeTextFileAtomically(targetPath, "second\n");
-    expect(await readFile(targetPath, "utf8")).toBe("second\n");
-  });
-});

package/src/services/filesystem.ts

@@ -1,183 +0,0 @@
-import { randomUUID } from "node:crypto";
-import {
-  access,
-  chmod,
-  lstat,
-  mkdir,
-  mkdtemp,
-  readdir,
-  readFile,
-  readlink,
-  rename,
-  rm,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-
-import { DevsyncError } from "./error.ts";
-
-export const pathExists = async (path: string) => {
-  try {
-    await access(path);
-
-    return true;
-  } catch (error: unknown) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return false;
-    }
-
-    throw error;
-  }
-};
-
-export const getPathStats = async (path: string) => {
-  try {
-    return await lstat(path);
-  } catch (error: unknown) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return undefined;
-    }
-
-    throw error;
-  }
-};
-
-export const listDirectoryEntries = async (path: string) => {
-  const entries = await readdir(path, { withFileTypes: true });
-
-  return entries.sort((left, right) => {
-    return left.name.localeCompare(right.name);
-  });
-};
-
-export const buildExecutableMode = (executable: boolean) => {
-  return executable ? 0o755 : 0o644;
-};
-
-export const isExecutableMode = (mode: number | bigint) => {
-  return (Number(mode) & 0o111) !== 0;
-};
-
-export const writeFileNode = async (
-  path: string,
-  node: Readonly<{
-    contents: string | Uint8Array;
-    executable: boolean;
-  }>,
-) => {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, node.contents);
-  await chmod(path, buildExecutableMode(node.executable));
-};
-
-export const writeSymlinkNode = async (path: string, linkTarget: string) => {
-  await mkdir(dirname(path), { recursive: true });
-  await rm(path, { force: true, recursive: true });
-  await symlink(linkTarget, path);
-};
-
-export const copyFilesystemNode = async (
-  sourcePath: string,
-  targetPath: string,
-  stats?: Awaited<ReturnType<typeof lstat>>,
-) => {
-  const sourceStats = stats ?? (await lstat(sourcePath));
-
-  if (sourceStats.isDirectory()) {
-    await mkdir(targetPath, { recursive: true });
-
-    const entries = await listDirectoryEntries(sourcePath);
-
-    for (const entry of entries) {
-      await copyFilesystemNode(
-        join(sourcePath, entry.name),
-        join(targetPath, entry.name),
-      );
-    }
-
-    return;
-  }
-
-  if (sourceStats.isSymbolicLink()) {
-    await writeSymlinkNode(targetPath, await readlink(sourcePath));
-
-    return;
-  }
-
-  if (!sourceStats.isFile()) {
-    throw new DevsyncError(`Unsupported filesystem entry: ${sourcePath}`);
-  }
-
-  await writeFileNode(targetPath, {
-    contents: await readFile(sourcePath),
-    executable: isExecutableMode(sourceStats.mode),
-  });
-};
-
-export const replacePathAtomically = async (
-  targetPath: string,
-  nextPath: string,
-) => {
-  const backupPath = join(
-    dirname(targetPath),
-    `.${basename(targetPath)}.devsync-sync-backup-${randomUUID()}`,
-  );
-  const existingStats = await getPathStats(targetPath);
-  let targetMoved = false;
-
-  try {
-    if (existingStats !== undefined) {
-      await rename(targetPath, backupPath);
-      targetMoved = true;
-    }
-
-    await rename(nextPath, targetPath);
-
-    if (targetMoved) {
-      await rm(backupPath, { force: true, recursive: true });
-    }
-  } catch (error: unknown) {
-    if (targetMoved && !(await pathExists(targetPath))) {
-      await rename(backupPath, targetPath).catch(() => {});
-    }
-
-    throw error;
-  } finally {
-    await rm(backupPath, { force: true, recursive: true }).catch(() => {});
-  }
-};
-
-export const removePathAtomically = async (targetPath: string) => {
-  const stats = await getPathStats(targetPath);
-
-  if (stats === undefined) {
-    return;
-  }
-
-  const backupPath = join(
-    dirname(targetPath),
-    `.${basename(targetPath)}.devsync-sync-remove-${randomUUID()}`,
-  );
-
-  await rename(targetPath, backupPath);
-  await rm(backupPath, { force: true, recursive: true });
-};
-
-export const writeTextFileAtomically = async (
-  targetPath: string,
-  contents: string,
-) => {
-  await mkdir(dirname(targetPath), { recursive: true });
-  const stagingDirectory = await mkdtemp(
-    join(dirname(targetPath), `.${basename(targetPath)}.devsync-sync-`),
-  );
-  const stagedPath = join(stagingDirectory, basename(targetPath));
-
-  try {
-    await writeFile(stagedPath, contents, "utf8");
-    await replacePathAtomically(targetPath, stagedPath);
-  } finally {
-    await rm(stagingDirectory, { force: true, recursive: true });
-  }
-};

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);
-  });
-});