@tinyrack/devsync 1.1.0 → 1.2.2

package/src/services/init.ts

@@ -1,244 +0,0 @@
-import { mkdir, readdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-
-import {
-  createInitialSyncConfig,
-  formatSyncConfig,
-  parseSyncConfig,
-  type ResolvedSyncConfig,
-  readSyncConfig,
-  resolveSyncArtifactsDirectoryPath,
-} from "#app/config/sync.ts";
-import { resolveConfiguredAbsolutePath } from "#app/config/xdg.ts";
-
-import { countConfiguredRules } from "./config-file.ts";
-import {
-  createAgeIdentityFile,
-  readAgeRecipientsFromIdentityFile,
-} from "./crypto.ts";
-import { DevsyncError } from "./error.ts";
-import { pathExists } from "./filesystem.ts";
-import { ensureRepository, initializeRepository } from "./git.ts";
-import { ensureSyncRepository, type SyncContext } from "./runtime.ts";
-
-export type SyncInitRequest = Readonly<{
-  identityFile?: string;
-  recipients: readonly string[];
-  repository?: string;
-}>;
-
-export type SyncInitResult = Readonly<{
-  alreadyInitialized: boolean;
-  configPath: string;
-  entryCount: number;
-  gitAction: "cloned" | "existing" | "initialized";
-  gitSource?: string;
-  identityFile: string;
-  generatedIdentity: boolean;
-  recipientCount: number;
-  ruleCount: number;
-  syncDirectory: string;
-}>;
-
-const defaultSyncIdentityFile = "$XDG_CONFIG_HOME/devsync/age/keys.txt";
-
-const normalizeRecipients = (recipients: readonly string[]) => {
-  return [
-    ...new Set(recipients.map((recipient) => recipient.trim()).filter(Boolean)),
-  ].sort((left, right) => {
-    return left.localeCompare(right);
-  });
-};
-
-const resolveInitAgeBootstrap = async (
-  request: SyncInitRequest,
-  context: Pick<SyncContext, "environment">,
-) => {
-  const configuredIdentityFile =
-    request.identityFile?.trim() || defaultSyncIdentityFile;
-  const identityFile = resolveConfiguredAbsolutePath(
-    configuredIdentityFile,
-    context.environment,
-  );
-  const explicitRecipients = normalizeRecipients(request.recipients);
-
-  if (explicitRecipients.length === 0) {
-    if (await pathExists(identityFile)) {
-      return {
-        configuredIdentityFile,
-        generatedIdentity: false,
-        recipients: normalizeRecipients(
-          await readAgeRecipientsFromIdentityFile(identityFile),
-        ),
-      };
-    }
-
-    const { recipient } = await createAgeIdentityFile(identityFile);
-
-    return {
-      configuredIdentityFile,
-      generatedIdentity: true,
-      recipients: [recipient],
-    };
-  }
-
-  if (await pathExists(identityFile)) {
-    return {
-      configuredIdentityFile,
-      generatedIdentity: false,
-      recipients: explicitRecipients,
-    };
-  }
-
-  const { recipient } = await createAgeIdentityFile(identityFile);
-
-  return {
-    configuredIdentityFile,
-    generatedIdentity: true,
-    recipients: normalizeRecipients([...explicitRecipients, recipient]),
-  };
-};
-
-const assertInitRequestMatchesConfig = (
-  config: ResolvedSyncConfig,
-  request: SyncInitRequest,
-  environment: NodeJS.ProcessEnv,
-) => {
-  const recipients = normalizeRecipients(request.recipients);
-
-  if (
-    recipients.length > 0 &&
-    JSON.stringify(recipients) !==
-      JSON.stringify(normalizeRecipients(config.age.recipients))
-  ) {
-    throw new DevsyncError(
-      "Sync configuration already exists with different recipients.",
-    );
-  }
-
-  if (
-    request.identityFile === undefined ||
-    request.identityFile.trim() === ""
-  ) {
-    return;
-  }
-
-  const resolvedIdentity = resolveConfiguredAbsolutePath(
-    request.identityFile,
-    environment,
-  );
-
-  if (resolvedIdentity !== config.age.identityFile) {
-    throw new DevsyncError(
-      "Sync configuration already exists with a different identity file.",
-    );
-  }
-};
-
-export const initializeSync = async (
-  request: SyncInitRequest,
-  context: SyncContext,
-): Promise<SyncInitResult> => {
-  const syncDirectory = context.paths.syncDirectory;
-  const configPath = context.paths.configPath;
-  const configExists = await pathExists(configPath);
-
-  if (configExists) {
-    await ensureSyncRepository(context);
-
-    const config = await readSyncConfig(syncDirectory, context.environment);
-    assertInitRequestMatchesConfig(config, request, context.environment);
-
-    return {
-      alreadyInitialized: true,
-      configPath,
-      entryCount: config.entries.length,
-      gitAction: "existing",
-      generatedIdentity: false,
-      identityFile: config.age.identityFile,
-      recipientCount: config.age.recipients.length,
-      ruleCount: countConfiguredRules(config),
-      syncDirectory,
-    };
-  }
-
-  await mkdir(dirname(syncDirectory), {
-    recursive: true,
-  });
-
-  let gitAction: SyncInitResult["gitAction"] = "existing";
-  let gitSource: string | undefined;
-
-  try {
-    await ensureRepository(syncDirectory);
-  } catch {
-    const syncDirectoryExists = await pathExists(syncDirectory);
-
-    if (syncDirectoryExists) {
-      const entries = await readdir(syncDirectory);
-
-      if (entries.length > 0) {
-        throw new DevsyncError(
-          `Sync directory already exists and is not empty: ${syncDirectory}`,
-        );
-      }
-    }
-
-    const gitResult = await initializeRepository(
-      syncDirectory,
-      request.repository?.trim() || undefined,
-    );
-
-    gitAction = gitResult.action;
-    gitSource = gitResult.source;
-  }
-
-  await mkdir(resolveSyncArtifactsDirectoryPath(syncDirectory), {
-    recursive: true,
-  });
-
-  if (await pathExists(configPath)) {
-    const config = await readSyncConfig(syncDirectory, context.environment);
-
-    assertInitRequestMatchesConfig(config, request, context.environment);
-
-    return {
-      alreadyInitialized: true,
-      configPath,
-      entryCount: config.entries.length,
-      gitAction,
-      ...(gitSource === undefined ? {} : { gitSource }),
-      generatedIdentity: false,
-      identityFile: config.age.identityFile,
-      recipientCount: config.age.recipients.length,
-      ruleCount: countConfiguredRules(config),
-      syncDirectory,
-    };
-  }
-
-  const ageBootstrap = await resolveInitAgeBootstrap(request, context);
-
-  const initialConfig = createInitialSyncConfig({
-    identityFile: ageBootstrap.configuredIdentityFile,
-    recipients: ageBootstrap.recipients,
-  });
-
-  parseSyncConfig(initialConfig, context.environment);
-  await writeFile(configPath, formatSyncConfig(initialConfig), "utf8");
-
-  return {
-    alreadyInitialized: false,
-    configPath,
-    entryCount: 0,
-    gitAction,
-    ...(gitSource === undefined ? {} : { gitSource }),
-    generatedIdentity: ageBootstrap.generatedIdentity,
-    identityFile: resolveConfiguredAbsolutePath(
-      ageBootstrap.configuredIdentityFile,
-      context.environment,
-    ),
-    recipientCount: ageBootstrap.recipients.length,
-    ruleCount: 0,
-    syncDirectory,
-  };
-};

package/src/services/list.ts

@@ -1,63 +0,0 @@
-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

@@ -1,421 +0,0 @@
-import { lstat, mkdir, mkdtemp, rm, symlink } from "node:fs/promises";
-import { basename, dirname, join, posix } from "node:path";
-
-import {
-  type ResolvedSyncConfig,
-  type ResolvedSyncConfigEntry,
-  resolveManagedSyncMode,
-} from "#app/config/sync.ts";
-import { DevsyncError } from "./error.ts";
-import {
-  copyFilesystemNode,
-  getPathStats,
-  listDirectoryEntries,
-  removePathAtomically,
-  replacePathAtomically,
-  writeFileNode,
-  writeSymlinkNode,
-} from "./filesystem.ts";
-import type { FileLikeSnapshotNode, SnapshotNode } from "./local-snapshot.ts";
-import { buildDirectoryKey } from "./paths.ts";
-
-type EntryMaterialization =
-  | Readonly<{
-      desiredKeys: ReadonlySet<string>;
-      type: "absent";
-    }>
-  | Readonly<{
-      desiredKeys: ReadonlySet<string>;
-      node: FileLikeSnapshotNode;
-      type: "file";
-    }>
-  | Readonly<{
-      desiredKeys: ReadonlySet<string>;
-      nodes: ReadonlyMap<string, FileLikeSnapshotNode>;
-      type: "directory";
-    }>;
-
-const copyIgnoredLocalNodesToDirectory = async (
-  sourceDirectory: string,
-  targetDirectory: string,
-  config: ResolvedSyncConfig,
-  repoPathPrefix: string,
-): Promise<number> => {
-  const stats = await getPathStats(sourceDirectory);
-
-  if (stats === undefined || !stats.isDirectory()) {
-    return 0;
-  }
-
-  let copiedNodeCount = 0;
-  const entries = await listDirectoryEntries(sourceDirectory);
-  const directoryMode = resolveManagedSyncMode(config, repoPathPrefix);
-
-  if (directoryMode === "ignore") {
-    await mkdir(targetDirectory, { recursive: true });
-    copiedNodeCount += 1;
-  }
-
-  for (const entry of entries) {
-    const sourcePath = join(sourceDirectory, entry.name);
-    const targetPath = join(targetDirectory, entry.name);
-    const repoPath = posix.join(repoPathPrefix, entry.name);
-    const entryStats = await lstat(sourcePath);
-
-    if (entryStats.isDirectory()) {
-      copiedNodeCount += await copyIgnoredLocalNodesToDirectory(
-        sourcePath,
-        targetPath,
-        config,
-        repoPath,
-      );
-      continue;
-    }
-
-    if (resolveManagedSyncMode(config, repoPath) !== "ignore") {
-      continue;
-    }
-
-    await mkdir(dirname(targetPath), { recursive: true });
-    await copyFilesystemNode(sourcePath, targetPath, entryStats);
-    copiedNodeCount += 1;
-  }
-
-  return copiedNodeCount;
-};
-
-const stageAndReplaceFilePath = async (
-  targetPath: string,
-  node: FileLikeSnapshotNode,
-) => {
-  await mkdir(dirname(targetPath), { recursive: true });
-  const stagingDirectory = await mkdtemp(
-    join(dirname(targetPath), `.${basename(targetPath)}.devsync-sync-`),
-  );
-  const stagedPath = join(stagingDirectory, basename(targetPath));
-
-  try {
-    if (node.type === "symlink") {
-      await symlink(node.linkTarget, stagedPath);
-    } else {
-      await writeFileNode(stagedPath, node);
-    }
-
-    await replacePathAtomically(targetPath, stagedPath);
-  } finally {
-    await rm(stagingDirectory, { force: true, recursive: true });
-  }
-};
-
-const stageAndReplaceMergedDirectoryPath = async (
-  entry: ResolvedSyncConfigEntry,
-  config: ResolvedSyncConfig,
-  desiredNodes: ReadonlyMap<string, FileLikeSnapshotNode>,
-) => {
-  await mkdir(dirname(entry.localPath), { recursive: true });
-  const stagingDirectory = await mkdtemp(
-    join(
-      dirname(entry.localPath),
-      `.${basename(entry.localPath)}.devsync-sync-`,
-    ),
-  );
-
-  try {
-    const preservedIgnoredNodeCount = await copyIgnoredLocalNodesToDirectory(
-      entry.localPath,
-      stagingDirectory,
-      config,
-      entry.repoPath,
-    );
-
-    for (const relativePath of [...desiredNodes.keys()].sort((left, right) => {
-      return left.localeCompare(right);
-    })) {
-      const node = desiredNodes.get(relativePath);
-
-      if (node === undefined) {
-        continue;
-      }
-
-      const targetNodePath = join(stagingDirectory, ...relativePath.split("/"));
-
-      if (node.type === "symlink") {
-        await writeSymlinkNode(targetNodePath, node.linkTarget);
-      } else {
-        await writeFileNode(targetNodePath, node);
-      }
-    }
-
-    if (preservedIgnoredNodeCount === 0 && desiredNodes.size === 0) {
-      await removePathAtomically(entry.localPath);
-
-      return;
-    }
-
-    await replacePathAtomically(entry.localPath, stagingDirectory);
-  } finally {
-    await rm(stagingDirectory, { force: true, recursive: true });
-  }
-};
-
-export const buildEntryMaterialization = (
-  entry: ResolvedSyncConfigEntry,
-  snapshot: ReadonlyMap<string, SnapshotNode>,
-): EntryMaterialization => {
-  if (entry.kind === "file") {
-    const node = snapshot.get(entry.repoPath);
-
-    if (node === undefined) {
-      return {
-        desiredKeys: new Set<string>(),
-        type: "absent",
-      };
-    }
-
-    if (node.type === "directory") {
-      throw new DevsyncError(
-        `File sync entry resolves to a directory in the repository: ${entry.repoPath}`,
-      );
-    }
-
-    return {
-      desiredKeys: new Set<string>([entry.repoPath]),
-      node,
-      type: "file",
-    };
-  }
-
-  const rootNode = snapshot.get(entry.repoPath);
-
-  if (rootNode !== undefined && rootNode.type !== "directory") {
-    throw new DevsyncError(
-      `Directory sync entry resolves to a file in the repository: ${entry.repoPath}`,
-    );
-  }
-
-  const nodes = new Map<string, FileLikeSnapshotNode>();
-  const desiredKeys = new Set<string>();
-
-  for (const [repoPath, node] of snapshot.entries()) {
-    if (!repoPath.startsWith(`${entry.repoPath}/`)) {
-      continue;
-    }
-
-    if (node.type === "directory") {
-      continue;
-    }
-
-    const relativePath = repoPath.slice(entry.repoPath.length + 1);
-
-    nodes.set(relativePath, node);
-    desiredKeys.add(repoPath);
-  }
-
-  if (rootNode === undefined && nodes.size === 0) {
-    return {
-      desiredKeys,
-      type: "absent",
-    };
-  }
-
-  desiredKeys.add(buildDirectoryKey(entry.repoPath));
-
-  return {
-    desiredKeys,
-    nodes,
-    type: "directory",
-  };
-};
-
-const collectLocalLeafKeys = async (
-  targetPath: string,
-  repoPathPrefix: string,
-  keys: Set<string>,
-  prefix?: string,
-) => {
-  const stats = await getPathStats(targetPath);
-
-  if (stats === undefined) {
-    return;
-  }
-
-  if (!stats.isDirectory()) {
-    keys.add(repoPathPrefix);
-
-    return;
-  }
-
-  keys.add(buildDirectoryKey(repoPathPrefix));
-
-  const entries = await listDirectoryEntries(targetPath);
-
-  for (const entry of entries) {
-    const absolutePath = join(targetPath, entry.name);
-    const relativePath =
-      prefix === undefined ? entry.name : `${prefix}/${entry.name}`;
-    const childStats = await lstat(absolutePath);
-
-    if (childStats?.isDirectory()) {
-      await collectLocalLeafKeys(
-        absolutePath,
-        repoPathPrefix,
-        keys,
-        relativePath,
-      );
-      continue;
-    }
-
-    keys.add(posix.join(repoPathPrefix, relativePath));
-  }
-};
-
-const collectIgnoredLocalKeys = async (
-  targetPath: string,
-  repoPath: string,
-  config: ResolvedSyncConfig,
-  keys: Set<string>,
-): Promise<boolean> => {
-  const stats = await getPathStats(targetPath);
-
-  if (stats === undefined) {
-    return false;
-  }
-
-  const mode = resolveManagedSyncMode(config, repoPath);
-
-  if (!stats.isDirectory()) {
-    if (mode !== "ignore") {
-      return false;
-    }
-
-    keys.add(repoPath);
-
-    return true;
-  }
-
-  let preservedIgnoredChildren = mode === "ignore";
-  const entries = await listDirectoryEntries(targetPath);
-
-  for (const entry of entries) {
-    const childPath = join(targetPath, entry.name);
-    const childRepoPath = posix.join(repoPath, entry.name);
-
-    preservedIgnoredChildren =
-      (await collectIgnoredLocalKeys(childPath, childRepoPath, config, keys)) ||
-      preservedIgnoredChildren;
-  }
-
-  if (mode === "ignore" || preservedIgnoredChildren) {
-    keys.add(buildDirectoryKey(repoPath));
-  }
-
-  return mode === "ignore" || preservedIgnoredChildren;
-};
-
-export const countDeletedLocalNodes = async (
-  entry: ResolvedSyncConfigEntry,
-  desiredKeys: ReadonlySet<string>,
-  config: ResolvedSyncConfig,
-  existingKeys: Set<string> = new Set<string>(),
-) => {
-  const preservedIgnoredKeys = new Set<string>();
-
-  await collectLocalLeafKeys(entry.localPath, entry.repoPath, existingKeys);
-  await collectIgnoredLocalKeys(
-    entry.localPath,
-    entry.repoPath,
-    config,
-    preservedIgnoredKeys,
-  );
-
-  return [...existingKeys].filter((key) => {
-    return !desiredKeys.has(key) && !preservedIgnoredKeys.has(key);
-  }).length;
-};
-
-export const applyEntryMaterialization = async (
-  entry: ResolvedSyncConfigEntry,
-  materialization: EntryMaterialization,
-  config: ResolvedSyncConfig,
-) => {
-  if (
-    entry.kind === "file" &&
-    resolveManagedSyncMode(config, entry.repoPath) === "ignore"
-  ) {
-    return;
-  }
-
-  if (materialization.type === "absent") {
-    if (entry.kind === "directory") {
-      await stageAndReplaceMergedDirectoryPath(entry, config, new Map());
-
-      return;
-    }
-
-    await removePathAtomically(entry.localPath);
-
-    return;
-  }
-
-  if (materialization.type === "file") {
-    await stageAndReplaceFilePath(entry.localPath, materialization.node);
-
-    return;
-  }
-
-  await stageAndReplaceMergedDirectoryPath(
-    entry,
-    config,
-    materialization.nodes,
-  );
-};
-
-export const buildPullCounts = (
-  materializations: readonly EntryMaterialization[],
-) => {
-  let decryptedFileCount = 0;
-  let directoryCount = 0;
-  let plainFileCount = 0;
-  let symlinkCount = 0;
-
-  for (const materialization of materializations) {
-    if (materialization === undefined) {
-      continue;
-    }
-
-    if (materialization.type === "file") {
-      if (materialization.node.type === "symlink") {
-        symlinkCount += 1;
-      } else if (materialization.node.secret) {
-        decryptedFileCount += 1;
-      } else {
-        plainFileCount += 1;
-      }
-
-      continue;
-    }
-
-    if (materialization.type !== "directory") {
-      continue;
-    }
-
-    directoryCount += 1;
-
-    for (const node of materialization.nodes.values()) {
-      if (node.type === "symlink") {
-        symlinkCount += 1;
-      } else if (node.secret) {
-        decryptedFileCount += 1;
-      } else {
-        plainFileCount += 1;
-      }
-    }
-  }
-
-  return {
-    decryptedFileCount,
-    directoryCount,
-    plainFileCount,
-    symlinkCount,
-  };
-};