@jakubmazanec/carson 0.1.0-a500263

package/src/workspace/WorkspaceDependencies.ts

@@ -0,0 +1,196 @@
+import _ from 'lodash';
+import semver from 'semver';
+
+import {compareSemver} from './internals.js';
+import {type Project} from './Project.js';
+import {type Workspace} from './Workspace.js';
+
+export interface WorkspaceDependencyProject {
+  name: string;
+  version: string;
+  exactVersion: string;
+}
+
+export interface WorkspaceDependency {
+  name: string;
+  versions: string[];
+  exactVersions: string[];
+
+  /** Associated project, if this dependency is actually a project in this workspace. */
+  project?: Project; // TODO: implement this
+
+  projects: WorkspaceDependencyProject[];
+}
+
+export interface WorkspaceDependenciesGetVersionsOptions {
+  useExactVersions?: boolean;
+}
+
+export interface WorkspaceDependenciesFromWorkspaceOptions {
+  includeDevDependencies?: boolean;
+  includeOnlyDevDependencies?: boolean;
+  includeWorkspaceDependencies?: boolean;
+}
+
+export class WorkspaceDependencies<M extends boolean = true> extends Array<WorkspaceDependency> {
+  workspace: Workspace<M>;
+
+  constructor(...args: [...WorkspaceDependency[], Workspace<M>]) {
+    super();
+
+    if (args.length === 1) {
+      [this.workspace] = args as [Workspace<M>];
+    } else {
+      let values = args.slice(0, -1) as WorkspaceDependency[];
+      let workspace = args.at(-1) as Workspace<M>;
+
+      this.push(...values);
+
+      this.workspace = workspace;
+    }
+  }
+
+  override push(...newWorkspaceDependencies: WorkspaceDependency[]): number {
+    for (let newWorkspaceDependency of newWorkspaceDependencies) {
+      let doesExist = false;
+
+      for (let workspaceDependency of this) {
+        if (workspaceDependency.name === newWorkspaceDependency.name) {
+          doesExist = true;
+
+          workspaceDependency.versions = _.union(
+            workspaceDependency.versions,
+            newWorkspaceDependency.versions,
+          );
+          workspaceDependency.exactVersions = _.union(
+            workspaceDependency.exactVersions,
+            newWorkspaceDependency.exactVersions,
+          );
+          workspaceDependency.projects = _.unionWith(
+            workspaceDependency.projects,
+            newWorkspaceDependency.projects,
+            (a, b) => a.name === b.name,
+          );
+
+          workspaceDependency.versions.sort(compareSemver);
+          workspaceDependency.exactVersions.sort(compareSemver);
+        }
+      }
+
+      if (!doesExist) {
+        super.push(newWorkspaceDependency);
+      }
+    }
+
+    return this.length;
+  }
+
+  // TODO: fix
+  // eslint-disable-next-line complexity -- TODO
+  static fromWorkspace<M extends boolean = true>(
+    workspace: Workspace<M>,
+    options?: WorkspaceDependenciesFromWorkspaceOptions,
+  ) {
+    let workspaceDependencies: WorkspaceDependency[] = [];
+
+    if (options?.includeWorkspaceDependencies) {
+      for (let [dependencyName, dependencyVersion] of Object.entries({
+        ...workspace.packageJson?.dependencies,
+        ...workspace.packageJson?.devDependencies,
+      })) {
+        let exactDependencyVersion = semver.validRange(dependencyVersion)
+          ? semver.minVersion(dependencyVersion)?.format() ??
+            semver.coerce(dependencyVersion)?.format() ??
+            dependencyVersion.trim()
+          : dependencyVersion.trim();
+
+        let workspaceDependency: WorkspaceDependency = {
+          name: dependencyName,
+          versions: [dependencyVersion],
+          exactVersions: [exactDependencyVersion],
+          projects: [],
+        };
+
+        workspaceDependencies.push(workspaceDependency);
+      }
+    }
+
+    for (let project of workspace.projects) {
+      if (!options?.includeOnlyDevDependencies) {
+        for (let [dependencyName, dependencyVersion] of Object.entries(
+          project.packageJson.dependencies ?? {},
+        )) {
+          let exactDependencyVersion = semver.validRange(dependencyVersion)
+            ? semver.minVersion(dependencyVersion)?.format() ??
+              semver.coerce(dependencyVersion)?.format() ??
+              dependencyVersion.trim()
+            : dependencyVersion.trim();
+
+          let workspaceDependency: WorkspaceDependency = {
+            name: dependencyName,
+            versions: [dependencyVersion],
+            exactVersions: [exactDependencyVersion],
+            projects: [],
+          };
+
+          if (project.name) {
+            workspaceDependency.projects = [
+              {
+                name: project.name,
+                version: dependencyVersion,
+                exactVersion: exactDependencyVersion,
+              },
+            ];
+          }
+
+          workspaceDependencies.push(workspaceDependency);
+        }
+      }
+
+      if (options?.includeDevDependencies || options?.includeOnlyDevDependencies) {
+        for (let [dependencyName, dependencyVersion] of Object.entries(
+          project.packageJson.devDependencies ?? {},
+        )) {
+          let exactDependencyVersion = semver.validRange(dependencyVersion)
+            ? semver.minVersion(dependencyVersion)?.format() ??
+              semver.coerce(dependencyVersion)?.format() ??
+              dependencyVersion.trim()
+            : dependencyVersion.trim();
+
+          let workspaceDependency: WorkspaceDependency = {
+            name: dependencyName,
+            versions: [dependencyVersion],
+            exactVersions: [exactDependencyVersion],
+            projects: [],
+          };
+
+          if (project.name) {
+            workspaceDependency.projects = [
+              {
+                name: project.name,
+                version: dependencyVersion,
+                exactVersion: exactDependencyVersion,
+              },
+            ];
+          }
+
+          workspaceDependencies.push(workspaceDependency);
+        }
+      }
+    }
+
+    return new this(...workspaceDependencies, workspace);
+  }
+
+  getVersions(options?: WorkspaceDependenciesGetVersionsOptions) {
+    let versions: Record<string, string[]> = {};
+
+    for (let dependency of this) {
+      versions[dependency.name] = options?.useExactVersions
+        ? dependency.exactVersions
+        : dependency.versions;
+    }
+
+    return versions;
+  }
+}

package/src/workspace/WorkspaceError.ts

@@ -0,0 +1,18 @@
+import {createCustomErrorWithData} from '@jakubmazanec/error';
+import {type ZodIssue} from 'zod';
+
+export const WorkspaceError = createCustomErrorWithData(
+  'WorkspaceError',
+  {
+    // MISSING_NAME_FIELD: 'No "name" field in file "{0}".',
+    INVALID_PACKAGE_JSON: 'Invalid package.json file "{0}".',
+    INVALID_WORKSPACE_CONFIG: 'Invalid workspace config file "{0}".',
+    NO_SUCH_WORKSPACE_PATH: 'Workspace path "{0}" doesn\'t exist.',
+    PATH_MISMATCH:
+      'In a single-project workspace, the workspace path must be the same as the project path.',
+  },
+  class WorkspaceErrorData {
+    path?: string;
+    zodIssues?: ZodIssue[];
+  },
+);

package/src/workspace/WorkspaceOptions.ts

@@ -0,0 +1,29 @@
+import {type PackageJson} from '@jakubmazanec/zod-utils';
+
+import {type WorkspaceConfig} from './WorkspaceConfig.js';
+import {type WorkspaceError} from './WorkspaceError.js';
+import {type WorkspaceOptionsProjectOptions} from './WorkspaceOptionsProjectOptions.js';
+import {type WorkspaceRepository} from './WorkspaceRepository.js';
+
+/**
+ * New workspace options.
+ */
+export type WorkspaceOptions<M extends boolean> = M extends true
+  ? {
+      path: string;
+      isMultiProject?: M;
+      projectGlobs?: string[];
+      projects?: WorkspaceOptionsProjectOptions[];
+      config?: WorkspaceConfig;
+      packageJson?: PackageJson;
+      repository?: WorkspaceRepository;
+      errors?: Array<InstanceType<typeof WorkspaceError>>;
+    }
+  : {
+      path: string;
+      isMultiProject?: M;
+      projects?: [WorkspaceOptionsProjectOptions];
+      config?: WorkspaceConfig;
+      repository?: WorkspaceRepository;
+      errors?: Array<InstanceType<typeof WorkspaceError>>;
+    };

package/src/workspace/WorkspaceOptionsProjectOptions.ts

@@ -0,0 +1,9 @@
+import {type PackageJson} from '@jakubmazanec/zod-utils';
+
+import {type ProjectConfig} from './ProjectConfig.js';
+
+export type WorkspaceOptionsProjectOptions = {
+  path: string;
+  config?: ProjectConfig;
+  packageJson?: PackageJson;
+};

package/src/workspace/WorkspacePackageJson.ts

@@ -0,0 +1,3 @@
+import {type PackageJson} from '@jakubmazanec/zod-utils';
+
+export type WorkspacePackageJson<M extends boolean> = M extends true ? PackageJson : null;

package/src/workspace/WorkspaceProjectGlobs.ts

@@ -0,0 +1 @@
+export type WorkspaceProjectGlobs<M extends boolean> = M extends true ? string[] : null;

package/src/workspace/WorkspaceProjects.ts

@@ -0,0 +1,3 @@
+import {type Project} from './Project.js';
+
+export type WorkspaceProjects<M extends boolean> = Array<Project<M>>; // TODO: should be `M extends true ? Array<Project<M>> : [Project<M>?]`; change when this is fixed: https://github.com/microsoft/TypeScript/issues/54302

package/src/workspace/WorkspaceRepository.ts

@@ -0,0 +1,4 @@
+export type WorkspaceRepository = {
+  branches: string[];
+  url: string;
+};

package/src/workspace/WorkspaceUpdateOptions.ts

@@ -0,0 +1,3 @@
+export type WorkspaceUpdateOptions = {
+  args: Record<string, unknown>;
+};

package/src/workspace/internals/compareSemver.ts

@@ -0,0 +1,35 @@
+import semver from 'semver';
+
+/**
+ * Defines sort order between two SemVer strings.
+ *
+ * @param a The first SemVer string.
+ * @param b The second SemvEr string.
+ * @returns Number whose positivity indicates the relative order of the two elements.
+ */
+export function compareSemver(a: string, b: string) {
+  let firstSemver = semver.validRange(a)
+    ? semver.minVersion(a)?.format() ?? semver.coerce(a)?.format() ?? '0.0.0'
+    : '0.0.0';
+  let secondSemver = semver.validRange(b)
+    ? semver.minVersion(b)?.format() ?? semver.coerce(b)?.format() ?? '0.0.0'
+    : '0.0.0';
+
+  let comparison = semver.compare(firstSemver, secondSemver);
+
+  if (comparison === 0 && (a !== firstSemver || b !== secondSemver)) {
+    if (a !== firstSemver && b !== secondSemver) {
+      return b.localeCompare(a);
+    }
+
+    if (a !== firstSemver) {
+      return 1;
+    }
+
+    if (b !== secondSemver) {
+      return -1;
+    }
+  }
+
+  return comparison;
+}

package/src/workspace/internals/getPackageJsonWorkspaces.ts

@@ -0,0 +1,11 @@
+import type {PackageJson} from '@jakubmazanec/zod-utils';
+
+export function getPackageJsonWorkspaces(packageJson: PackageJson) {
+  if (Array.isArray(packageJson.workspaces)) {
+    return packageJson.workspaces;
+  } else if (packageJson.workspaces?.packages) {
+    return packageJson.workspaces.packages;
+  }
+
+  return undefined;
+}

package/src/workspace/internals/getRepositoryBranches.ts

@@ -0,0 +1,25 @@
+import {simpleGit} from 'simple-git';
+
+const REMOTE_NAME_PREFIX_REGEXP = /^[^/]*\//iu;
+
+export async function getRepositoryBranches(repositoryPath: string): Promise<string[] | undefined> {
+  let repositoryBranches: string[] | undefined;
+
+  try {
+    let git = simpleGit({
+      baseDir: repositoryPath,
+      binary: 'git',
+      maxConcurrentProcesses: 1,
+    });
+
+    let branchSummary = await git.branch(['-r']);
+
+    repositoryBranches = branchSummary.all.map((branch) =>
+      branch.replace(REMOTE_NAME_PREFIX_REGEXP, ''),
+    );
+  } catch (error) {
+    // no-op
+  }
+
+  return repositoryBranches;
+}

package/src/workspace/internals/getRepositoryUrl.ts

@@ -0,0 +1,23 @@
+import {simpleGit} from 'simple-git';
+
+export async function getRepositoryUrl(repositoryPath: string): Promise<string | undefined> {
+  let repositoryUrl: string | undefined;
+
+  try {
+    // load git repo
+    let git = simpleGit({
+      baseDir: repositoryPath,
+      binary: 'git',
+      maxConcurrentProcesses: 1,
+    });
+    let {value} = await git.getConfig('remote.origin.url');
+
+    if (value) {
+      repositoryUrl = value;
+    }
+  } catch {
+    // no-op
+  }
+
+  return repositoryUrl;
+}

package/src/workspace/internals.ts

@@ -0,0 +1,4 @@
+export * from './internals/compareSemver.js';
+export * from './internals/getPackageJsonWorkspaces.js';
+export * from './internals/getRepositoryBranches.js';
+export * from './internals/getRepositoryUrl.js';

package/src/workspace/saveProjectConfig.ts

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+import {type ProjectConfig} from './ProjectConfig.js';
+import {CARSON_CONFIG_DIRECTORY, PROJECT_CONFIG_FILENAME} from '../constants.js';
+import {prettify} from '../template/internals.js';
+
+export type SaveProjectConfigOptions = {
+  projectPath: string;
+  projectConfig: ProjectConfig;
+};
+
+export async function saveProjectConfig({projectPath, projectConfig}: SaveProjectConfigOptions) {
+  await fs.ensureDir(path.join(projectPath, CARSON_CONFIG_DIRECTORY));
+
+  let projectConfigPath = path.join(projectPath, CARSON_CONFIG_DIRECTORY, PROJECT_CONFIG_FILENAME);
+
+  await fs.writeFile(
+    projectConfigPath,
+    await prettify(JSON.stringify(projectConfig), projectConfigPath),
+    {encoding: 'utf8'},
+  );
+}

package/src/workspace/saveWorkspaceConfig.ts

@@ -0,0 +1,30 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+import {type WorkspaceConfig} from './WorkspaceConfig.js';
+import {CARSON_CONFIG_DIRECTORY, WORKSPACE_CONFIG_FILENAME} from '../constants.js';
+import {prettify} from '../template/internals.js';
+
+export type SaveWorkspaceConfigOptions = {
+  workspacePath: string;
+  workspaceConfig: WorkspaceConfig;
+};
+
+export async function saveWorkspaceConfig({
+  workspacePath,
+  workspaceConfig,
+}: SaveWorkspaceConfigOptions) {
+  await fs.ensureDir(path.join(workspacePath, CARSON_CONFIG_DIRECTORY));
+
+  let workspaceConfigPath = path.join(
+    workspacePath,
+    CARSON_CONFIG_DIRECTORY,
+    WORKSPACE_CONFIG_FILENAME,
+  );
+
+  await fs.writeFile(
+    workspaceConfigPath,
+    await prettify(JSON.stringify(workspaceConfig), workspaceConfigPath),
+    {encoding: 'utf8'},
+  );
+}

package/src/workspace.ts

@@ -0,0 +1,10 @@
+export * from './workspace/Project.js';
+export * from './workspace/ProjectConfig.js';
+export * from './workspace/ProjectError.js';
+export * from './workspace/saveProjectConfig.js';
+export * from './workspace/saveWorkspaceConfig.js';
+export * from './workspace/Workspace.js';
+export * from './workspace/WorkspaceConfig.js';
+export * from './workspace/WorkspaceDependencies.js';
+export * from './workspace/WorkspaceError.js';
+export * from './workspace/WorkspaceRepository.js';