@tinyrack/devsync 1.1.0 → 1.3.0

package/src/services/local-snapshot.ts

@@ -1,173 +0,0 @@
-import { lstat, readFile, readlink } from "node:fs/promises";
-import { join, posix } from "node:path";
-
-import {
-  type ResolvedSyncConfig,
-  resolveManagedSyncMode,
-} from "#app/config/sync.ts";
-import { DevsyncError } from "./error.ts";
-import {
-  getPathStats,
-  isExecutableMode,
-  listDirectoryEntries,
-} from "./filesystem.ts";
-import { assertStorageSafeRepoPath } from "./repo-artifacts.ts";
-
-export type SnapshotNode =
-  | Readonly<{
-      type: "directory";
-    }>
-  | Readonly<{
-      executable: boolean;
-      secret: boolean;
-      type: "file";
-      contents: Uint8Array;
-    }>
-  | Readonly<{
-      linkTarget: string;
-      type: "symlink";
-    }>;
-
-export type FileSnapshotNode = Extract<
-  SnapshotNode,
-  Readonly<{ type: "file" }>
->;
-
-export type FileLikeSnapshotNode = Extract<
-  SnapshotNode,
-  Readonly<{ type: "file" | "symlink" }>
->;
-
-export const addSnapshotNode = (
-  snapshot: Map<string, SnapshotNode>,
-  repoPath: string,
-  node: SnapshotNode,
-) => {
-  if (snapshot.has(repoPath)) {
-    throw new DevsyncError(`Duplicate sync path generated for ${repoPath}`);
-  }
-
-  snapshot.set(repoPath, node);
-};
-
-const addLocalNode = async (
-  snapshot: Map<string, SnapshotNode>,
-  config: ResolvedSyncConfig,
-  repoPath: string,
-  path: string,
-  stats: Awaited<ReturnType<typeof lstat>>,
-) => {
-  assertStorageSafeRepoPath(repoPath);
-  const mode = resolveManagedSyncMode(config, repoPath);
-
-  if (mode === "ignore") {
-    return;
-  }
-
-  if (stats.isDirectory()) {
-    throw new DevsyncError(
-      `Expected a file-like path but found a directory: ${path}`,
-    );
-  }
-
-  if (stats.isSymbolicLink()) {
-    if (mode === "secret") {
-      throw new DevsyncError(
-        `Secret sync paths must be regular files, not symlinks: ${repoPath}`,
-      );
-    }
-
-    addSnapshotNode(snapshot, repoPath, {
-      linkTarget: await readlink(path),
-      type: "symlink",
-    });
-
-    return;
-  }
-
-  if (!stats.isFile()) {
-    throw new DevsyncError(`Unsupported filesystem entry: ${path}`);
-  }
-
-  addSnapshotNode(snapshot, repoPath, {
-    contents: await readFile(path),
-    executable: isExecutableMode(stats.mode),
-    secret: mode === "secret",
-    type: "file",
-  });
-};
-
-const walkLocalDirectory = async (
-  snapshot: Map<string, SnapshotNode>,
-  config: ResolvedSyncConfig,
-  localDirectory: string,
-  repoPathPrefix: string,
-) => {
-  const entries = await listDirectoryEntries(localDirectory);
-
-  for (const entry of entries) {
-    const localPath = join(localDirectory, entry.name);
-    const repoPath = posix.join(repoPathPrefix, entry.name);
-    const stats = await lstat(localPath);
-
-    if (stats.isDirectory()) {
-      assertStorageSafeRepoPath(repoPath);
-      await walkLocalDirectory(snapshot, config, localPath, repoPath);
-      continue;
-    }
-
-    await addLocalNode(snapshot, config, repoPath, localPath, stats);
-  }
-};
-
-export const buildLocalSnapshot = async (config: ResolvedSyncConfig) => {
-  const snapshot = new Map<string, SnapshotNode>();
-
-  for (const entry of config.entries) {
-    const stats = await getPathStats(entry.localPath);
-
-    if (stats === undefined) {
-      continue;
-    }
-
-    const entryMode = resolveManagedSyncMode(config, entry.repoPath);
-
-    if (entry.kind === "file") {
-      if (entryMode === "ignore") {
-        continue;
-      }
-
-      if (stats.isDirectory()) {
-        throw new DevsyncError(
-          `Sync entry ${entry.name} expects a file, but found a directory: ${entry.localPath}`,
-        );
-      }
-
-      await addLocalNode(
-        snapshot,
-        config,
-        entry.repoPath,
-        entry.localPath,
-        stats,
-      );
-      continue;
-    }
-
-    if (!stats.isDirectory()) {
-      throw new DevsyncError(
-        `Sync entry ${entry.name} expects a directory: ${entry.localPath}`,
-      );
-    }
-
-    const snapshotSizeBeforeWalk = snapshot.size;
-    await walkLocalDirectory(snapshot, config, entry.localPath, entry.repoPath);
-
-    if (entryMode !== "ignore" || snapshot.size > snapshotSizeBeforeWalk) {
-      addSnapshotNode(snapshot, entry.repoPath, {
-        type: "directory",
-      });
-    }
-  }
-
-  return snapshot;
-};

package/src/services/paths.test.ts

@@ -1,74 +0,0 @@
-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/paths.ts

@@ -1,98 +0,0 @@
-import { isAbsolute, relative, resolve } from "node:path";
-
-import { normalizeSyncRepoPath } from "#app/config/sync.ts";
-import { expandHomePath } from "#app/config/xdg.ts";
-
-import { DevsyncError } from "./error.ts";
-
-export const buildDirectoryKey = (repoPath: string) => {
-  return `${repoPath}/`;
-};
-
-export const isPathEqualOrNested = (path: string, rootPath: string) => {
-  const rootToPath = relative(rootPath, path);
-
-  return (
-    rootToPath === "" ||
-    (!isAbsolute(rootToPath) &&
-      !rootToPath.startsWith("..") &&
-      rootToPath !== "..")
-  );
-};
-
-export const doPathsOverlap = (leftPath: string, rightPath: string) => {
-  return (
-    isPathEqualOrNested(leftPath, rightPath) ||
-    isPathEqualOrNested(rightPath, leftPath)
-  );
-};
-
-export const isExplicitLocalPath = (target: string) => {
-  return (
-    target === "." ||
-    target === ".." ||
-    target === "~" ||
-    target.startsWith("./") ||
-    target.startsWith("../") ||
-    target.startsWith("~/") ||
-    isAbsolute(target)
-  );
-};
-
-export const resolveCommandTargetPath = (
-  target: string,
-  environment: NodeJS.ProcessEnv,
-  cwd: string,
-) => {
-  return resolve(cwd, expandHomePath(target, environment));
-};
-
-export const buildRepoPathWithinRoot = (
-  absolutePath: string,
-  rootPath: string,
-  description: string,
-) => {
-  const relativePath = relative(rootPath, absolutePath);
-
-  if (relativePath === "") {
-    throw new DevsyncError(
-      `${description} must be inside ${rootPath}, not the root itself: ${absolutePath}`,
-    );
-  }
-
-  if (
-    isAbsolute(relativePath) ||
-    relativePath.startsWith("..") ||
-    relativePath === ".."
-  ) {
-    throw new DevsyncError(
-      `${description} must be inside ${rootPath}: ${absolutePath}`,
-    );
-  }
-
-  return normalizeSyncRepoPath(relativePath);
-};
-
-export const buildConfiguredHomeLocalPath = (repoPath: string) => {
-  return `~/${repoPath}`;
-};
-
-export const tryBuildRepoPathWithinRoot = (
-  absolutePath: string,
-  rootPath: string,
-  description: string,
-) => {
-  try {
-    return buildRepoPathWithinRoot(absolutePath, rootPath, description);
-  } catch {
-    return undefined;
-  }
-};
-
-export const tryNormalizeRepoPathInput = (value: string) => {
-  try {
-    return normalizeSyncRepoPath(value);
-  } catch {
-    return undefined;
-  }
-};

package/src/services/pull.ts

@@ -1,144 +0,0 @@
-import { type ResolvedSyncConfig, readSyncConfig } from "#app/config/sync.ts";
-
-import {
-  applyEntryMaterialization,
-  buildEntryMaterialization,
-  buildPullCounts,
-  countDeletedLocalNodes,
-} from "./local-materialization.ts";
-import { buildRepositorySnapshot } from "./repo-snapshot.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncPullRequest = Readonly<{
-  dryRun: boolean;
-}>;
-
-export type SyncPullResult = Readonly<{
-  configPath: string;
-  decryptedFileCount: number;
-  deletedLocalCount: number;
-  directoryCount: number;
-  dryRun: boolean;
-  plainFileCount: number;
-  symlinkCount: number;
-  syncDirectory: string;
-}>;
-
-export type PullPlan = Readonly<{
-  counts: ReturnType<typeof buildPullCounts>;
-  deletedLocalCount: number;
-  desiredKeys: ReadonlySet<string>;
-  existingKeys: ReadonlySet<string>;
-  materializations: readonly ReturnType<typeof buildEntryMaterialization>[];
-}>;
-
-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,
-  );
-  const materializations = config.entries.map((entry) => {
-    return buildEntryMaterialization(entry, snapshot);
-  });
-
-  let deletedLocalCount = 0;
-  const existingKeys = new Set<string>();
-
-  for (let index = 0; index < config.entries.length; index += 1) {
-    const entry = config.entries[index];
-    const materialization = materializations[index];
-
-    if (entry === undefined || materialization === undefined) {
-      continue;
-    }
-
-    deletedLocalCount += await countDeletedLocalNodes(
-      entry,
-      materialization.desiredKeys,
-      config,
-      existingKeys,
-    );
-  }
-
-  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: plan.deletedLocalCount,
-    dryRun,
-    syncDirectory: context.paths.syncDirectory,
-    ...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

@@ -1,168 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-
-import {
-  type ResolvedSyncConfig,
-  readSyncConfig,
-  resolveSyncArtifactsDirectoryPath,
-} from "#app/config/sync.ts";
-
-import { replacePathAtomically } from "./filesystem.ts";
-import { buildLocalSnapshot, type SnapshotNode } from "./local-snapshot.ts";
-import {
-  buildArtifactKey,
-  buildRepoArtifacts,
-  collectExistingArtifactKeys,
-  writeArtifactsToDirectory,
-} from "./repo-artifacts.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncPushRequest = Readonly<{
-  dryRun: boolean;
-}>;
-
-export type SyncPushResult = Readonly<{
-  configPath: string;
-  deletedArtifactCount: number;
-  directoryCount: number;
-  dryRun: boolean;
-  encryptedFileCount: number;
-  plainFileCount: number;
-  symlinkCount: number;
-  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;
-  let plainFileCount = 0;
-  let symlinkCount = 0;
-
-  for (const node of snapshot.values()) {
-    if (node.type === "directory") {
-      directoryCount += 1;
-      continue;
-    }
-
-    if (node.type === "symlink") {
-      symlinkCount += 1;
-      continue;
-    }
-
-    if (node.secret) {
-      encryptedFileCount += 1;
-    } else {
-      plainFileCount += 1;
-    }
-  }
-
-  return {
-    directoryCount,
-    encryptedFileCount,
-    plainFileCount,
-    symlinkCount,
-  };
-};
-
-export const buildPushPlan = async (
-  config: ResolvedSyncConfig,
-  context: SyncContext,
-): Promise<PushPlan> => {
-  const snapshot = await buildLocalSnapshot(config);
-  const artifacts = await buildRepoArtifacts(snapshot, config);
-  const desiredArtifactKeys = new Set(
-    artifacts.map((artifact) => {
-      return buildArtifactKey(artifact);
-    }),
-  );
-  const existingArtifactKeys = await collectExistingArtifactKeys(
-    context.paths.syncDirectory,
-    config,
-  );
-  const deletedArtifactCount = [...existingArtifactKeys].filter((key) => {
-    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-"),
-    );
-    const nextArtifactsDirectory = join(stagingRoot, "files");
-
-    try {
-      const artifacts = await buildRepoArtifacts(plan.snapshot, config);
-
-      await writeArtifactsToDirectory(nextArtifactsDirectory, artifacts);
-
-      await replacePathAtomically(
-        resolveSyncArtifactsDirectoryPath(context.paths.syncDirectory),
-        nextArtifactsDirectory,
-      );
-    } finally {
-      await rm(stagingRoot, {
-        force: true,
-        recursive: true,
-      });
-    }
-  }
-
-  return buildPushResultFromPlan(plan, context, request.dryRun);
-};