@stack-dev/cli 0.1.0

package/src/unlink-packages.ts

@@ -0,0 +1,47 @@
+import { getDirectoryPackageJson, getPackageJSONPath } from './utils/utils';
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TSConfig } from './tsconfig';
+import { Package } from './utils/package';
+import { getNamespace } from './utils/workspace';
+
+export async function unlinkPackages(
+  current: Package,
+  target: Package,
+): Promise<void> {
+  await updatePackageJSON(current, target);
+  await updateTSConfig(current, target);
+}
+
+async function updatePackageJSON(current: Package, target: Package) {
+  const namespace = await getNamespace();
+
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = packageJSON
+    .removeDependency(target.name)
+    .removeDevDependency(target.name);
+
+  const packageJSONPath = getPackageJSONPath(current.directory);
+
+  await fs.writeFile(packageJSONPath, updated.format(namespace));
+}
+
+async function updateTSConfig(current: Package, target: Package) {
+  const tsconfigPath = path.join(current.directory, 'tsconfig.json');
+  const tsconfigContents = await fs.readFile(tsconfigPath, 'utf8');
+  const tsconfig = TSConfig.parse(tsconfigContents);
+
+  const updatedPaths = Object.fromEntries(
+    Object.entries(tsconfig.compilerOptions.paths).filter(
+      ([key]) => key !== target.name,
+    ),
+  );
+
+  const updatedCompilerOptions =
+    tsconfig.compilerOptions.setPaths(updatedPaths);
+
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+
+  await fs.writeFile(tsconfigPath, updated.format());
+}

package/src/utils/package-generator.ts

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { FileGenerator, PackageJsonGenerator } from '../file-generator';
+
+export class PackageGenerator {
+  private readonly _root: string;
+
+  private readonly _packageJson: PackageJsonGenerator;
+
+  private readonly _fileGenerators: ReadonlyArray<FileGenerator>;
+
+  public constructor(
+    root: string,
+    packageJson: PackageJsonGenerator,
+    fileGenerators: ReadonlyArray<FileGenerator> = [],
+  ) {
+    this._root = root;
+    this._packageJson = packageJson;
+    this._fileGenerators = fileGenerators;
+  }
+
+  public async generate(): Promise<void> {
+    const all = [this._packageJson, ...this._fileGenerators];
+
+    await fs.mkdir(this._root, { recursive: true });
+
+    await Promise.all(all.map((gen) => this.write(gen)));
+  }
+
+  private async write(fileGenerator: FileGenerator): Promise<void> {
+    const contents = await fileGenerator.generate();
+
+    const filepath = path.join(this._root, fileGenerator.filepath);
+
+    const directory = path.dirname(filepath);
+
+    await fs.mkdir(directory, { recursive: true });
+
+    await fs.writeFile(filepath, contents);
+  }
+}

package/src/utils/package-type.ts

@@ -0,0 +1,44 @@
+import { prompt } from 'enquirer';
+
+export const packageTypes = [
+  'library',
+  'config',
+  'react',
+  'vite',
+  'fastify',
+  'next',
+  'cli',
+] as const;
+
+export type PackageType = (typeof packageTypes)[number];
+
+export async function pickPackageType(
+  options?: Record<string, string | undefined>,
+): Promise<PackageType> {
+  if (options?.type && isPackageType(options.type)) {
+    return options.type;
+  } else if (options?.type && !isPackageType(options.type)) {
+    throw new Error(
+      `--type setting "${options.type}" is invalid, must be one of ${packageTypes.join(', ')}.`,
+    );
+  }
+
+  const response = await prompt<{ type: string }>({
+    type: 'select',
+    name: 'type',
+    message: 'What kind of package do you want?',
+    choices: [...packageTypes],
+  });
+
+  if (!isPackageType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${packageTypes.join(', ')}.`,
+    );
+  }
+
+  return response.type;
+}
+
+export function isPackageType(s: string): s is PackageType {
+  return packageTypes.some((p) => p === s);
+}

package/src/utils/package.ts

@@ -0,0 +1,126 @@
+import { fileExists, getDirectoryPackageJson } from './utils';
+import { getDirectoryWorkspaceFile, getWorkspaceRoot } from './workspace';
+
+import { glob } from 'fast-glob';
+import path from 'node:path';
+
+// TODO: make into class with PackageJSON.
+// TODO: Create Workspace/context...
+export type Package = {
+  name: string;
+
+  directory: string;
+
+  type: 'Config' | 'App' | 'Library' | 'Unknown';
+};
+
+export async function getCurrentPackage(
+  directory: string = process.cwd(),
+): Promise<Package> {
+  const packageRoot = await getPackageRoot(directory);
+  const packageJson = await getDirectoryPackageJson(packageRoot);
+
+  return getPackageByName(packageJson.name);
+}
+
+export async function getPackageRoot(
+  directory: string = process.cwd(),
+): Promise<string> {
+  const parent = path.dirname(directory);
+
+  if (parent === directory) {
+    throw new Error('Not a package.');
+  }
+
+  if (await isPackageRoot(directory)) {
+    return directory;
+  }
+
+  return getPackageRoot(parent);
+}
+
+export async function getPackageByName(name: string): Promise<Package> {
+  const all = await getAllPackages();
+
+  const match = all.find((p) => p.name === name);
+
+  if (match === undefined) {
+    throw new Error(`No package with name "${name}".`);
+  }
+
+  return match;
+}
+
+export async function getAllPackages(
+  directory: string = process.cwd(),
+): Promise<ReadonlyArray<Package>> {
+  const workspaceRoot = await getWorkspaceRoot(directory);
+  const workspaceFile = (await getDirectoryWorkspaceFile(workspaceRoot)) as {
+    packages: ReadonlyArray<string>;
+  };
+
+  const results: Array<Package> = [];
+
+  for (const seg of workspaceFile.packages) {
+    const packageType = getPackageType(seg);
+
+    const packageJsonPaths = await glob(`${workspaceRoot}/${seg}/package.json`);
+
+    const packageDirectories = packageJsonPaths.map((p) => path.dirname(p));
+
+    for (const directory of packageDirectories) {
+      const name = (await getDirectoryPackageJson(directory)).name;
+
+      results.push({
+        name,
+        directory,
+        type: packageType,
+      });
+    }
+  }
+
+  return results;
+}
+
+function getPackageType(segment: string): Package['type'] {
+  if (segment.startsWith('app')) {
+    return 'App';
+  } else if (segment.startsWith('config')) {
+    return 'Config';
+  } else if (segment.startsWith('package') || segment.startsWith('lib')) {
+    return 'Library';
+  } else {
+    return 'Unknown';
+  }
+}
+
+export function comparePackages(a: Package, b: Package): number {
+  const packageTypeDifference = comparePackageTypes(a.type, b.type);
+
+  if (packageTypeDifference !== 0) {
+    return packageTypeDifference;
+  } else {
+    return a.name.localeCompare(b.name);
+  }
+}
+
+function comparePackageTypes(a: Package['type'], b: Package['type']): number {
+  return getPackageTypeIndex(a) - getPackageTypeIndex(b);
+}
+
+function getPackageTypeIndex(packageType: Package['type']): number {
+  switch (packageType) {
+    case 'Library':
+      return 0;
+    case 'Config':
+      return 1;
+    case 'App':
+      return 2;
+    case 'Unknown':
+      return 3;
+  }
+}
+
+async function isPackageRoot(directory: string): Promise<boolean> {
+  return await fileExists(path.join(directory, 'package.json'));
+}

package/src/utils/style-type.ts

@@ -0,0 +1,41 @@
+import { prompt } from 'enquirer';
+
+export const styleTypes = [
+  'tailwind',
+  'css-modules',
+  'styled-components',
+  'none',
+] as const;
+
+export type StyleType = (typeof styleTypes)[number];
+
+export async function pickStyleType(
+  options?: Record<string, string | undefined>,
+): Promise<StyleType> {
+  if (options?.style && isStyleType(options?.style)) {
+    return options?.style;
+  } else if (options?.style && !isStyleType(options?.style)) {
+    throw new Error(
+      `--style setting "${options.style}" is invalid, must be one of ${styleTypes.join(', ')}.`,
+    );
+  }
+
+  const response = await prompt<{ type: string }>({
+    type: 'select',
+    name: 'type',
+    message: 'What kind of style do you want?',
+    choices: [...styleTypes],
+  });
+
+  if (!isStyleType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${styleTypes.join(', ')}.`,
+    );
+  }
+
+  return response.type;
+}
+
+export function isStyleType(s: string): s is StyleType {
+  return styleTypes.some((p) => p === s);
+}

package/src/utils/utils.ts

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { PackageJSON } from '../package-json/package-json';
+
+export async function getDirectoryPackageJson(
+  directory: string,
+): Promise<PackageJSON> {
+  const packageJsonPath = getPackageJSONPath(directory);
+  const packageJsonText = await fs.readFile(packageJsonPath, {
+    encoding: 'utf-8',
+  });
+
+  return PackageJSON.parse(packageJsonText);
+}
+
+export function getPackageJSONPath(directory: string) {
+  return path.join(directory, 'package.json');
+}
+
+export async function fileExists(filepath: string): Promise<boolean> {
+  try {
+    await fs.access(filepath, fs.constants.F_OK);
+
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/workspace.ts

@@ -0,0 +1,78 @@
+import { fileExists, getDirectoryPackageJson } from './utils';
+
+import { Snapshot } from '@stack-dev/core';
+import fs from 'node:fs/promises';
+import path from 'path';
+import yaml from 'yaml';
+
+export type WorkspaceYaml = {
+  packages: ReadonlyArray<string>;
+};
+
+export async function getDirectoryWorkspaceFile(
+  directory: string,
+): Promise<WorkspaceYaml> {
+  const raw = await getRawDirectoryWorkspaceFile(directory);
+
+  if ('packages' in raw && raw.packages instanceof Array) {
+    return {
+      packages: raw.packages.filter((p): p is string => typeof p === 'string'),
+    };
+  } else {
+    return { packages: [] };
+  }
+}
+
+async function getRawDirectoryWorkspaceFile(
+  directory: string,
+): Promise<Snapshot> {
+  const case1 = path.join(directory, 'pnpm-workspace.yaml');
+  const case2 = path.join(directory, 'pnpm-workspace.yml');
+
+  if (await fileExists(case1)) {
+    return yaml.parse(await fs.readFile(case1, { encoding: 'utf-8' }));
+  } else if (await fileExists(case2)) {
+    return yaml.parse(await fs.readFile(case2, { encoding: 'utf-8' }));
+  } else {
+    throw new Error(`Directory "${directory}" is not a workspace.`);
+  }
+}
+
+export async function isWorkspaceRoot(directory: string): Promise<boolean> {
+  return (
+    (await fileExists(path.join(directory, 'pnpm-workspace.yaml'))) ||
+    (await fileExists(path.join(directory, 'pnpm-workspace.yml')))
+  );
+}
+
+export async function getWorkspaceRoot(
+  directory: string = process.cwd(),
+): Promise<string> {
+  const parent = path.dirname(directory);
+
+  if (parent === directory) {
+    throw new Error('Not a workspace.');
+  }
+
+  if (await isWorkspaceRoot(directory)) {
+    return directory;
+  }
+
+  return getWorkspaceRoot(parent);
+}
+
+export async function getNamespace(
+  directory: string = process.cwd(),
+): Promise<string> {
+  const root = await getWorkspaceRoot(directory);
+
+  const packageJson = await getDirectoryPackageJson(root);
+
+  const result = packageJson.name;
+
+  if (!result) {
+    throw new Error('Missing name.');
+  }
+
+  return `@${result}`;
+}

package/src/workspace/create-workspace.ts

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getNamespace } from '../utils/workspace';
+import { makeRootPackage } from './root-package';
+import { makeTypescriptConfig } from './typescript-config';
+
+export async function createWorkspace(name: string, directory: string) {
+  await validateNotInWorkspace(directory);
+
+  console.log(`✨ Creating workspace: @${name}`);
+
+  const fullPath = path.join(directory, name);
+
+  await fs.mkdir(fullPath, { recursive: true });
+
+  const namespace = `@${name}`;
+  const PACKAGES = [
+    await makeRootPackage(fullPath, name),
+    await makeTypescriptConfig(fullPath, namespace),
+  ];
+
+  await Promise.all(PACKAGES.map((p) => p.generate()));
+
+  await fs.mkdir(path.join(fullPath, 'apps'));
+  await fs.mkdir(path.join(fullPath, 'configs'));
+  await fs.mkdir(path.join(fullPath, 'packages'));
+
+  console.log(`✅ Workspace created at: ${fullPath}`);
+  console.log('');
+  console.log(`Run "cd ${fullPath}" followed by "pnpm install"`);
+}
+
+async function validateNotInWorkspace(directory: string): Promise<void> {
+  const namespace = await getNamespace(directory);
+
+  if (namespace !== undefined) {
+    throw new Error(`Currently in workspace "${namespace}".`);
+  }
+}

package/src/workspace/index.ts

@@ -0,0 +1 @@
+export * from './create-workspace';

package/src/workspace/root-package.ts

@@ -0,0 +1,195 @@
+import { PackageJsonGenerator } from '../file-generator';
+import { FileGeneratorImp } from '../file-generator/file-generator-imp';
+import { Dependency, PackageJSON } from '../package-json';
+import { PackageGenerator } from '../utils/package-generator';
+
+export async function makeRootPackage(
+  directory: string,
+  name: string,
+): Promise<PackageGenerator> {
+  const packageJsonModel = new PackageJSON({
+    name: name,
+    devDependencies: [new Dependency('turbo', '^2.5.4')],
+    additionalData: {
+      description: '',
+      keywords: [],
+      author: '',
+      license: 'ISC',
+      packageManager: 'pnpm@10.13.1',
+    },
+  });
+
+  const PNPM_WORKSPACE = new FileGeneratorImp(
+    'pnpm-workspace.yaml',
+    ['packages:', '  - apps/*', '  - packages/*', '  - configs/*'].join('\n'),
+  );
+
+  const GITIGNORE = new FileGeneratorImp('.gitignore', GITIGNORE_CONTENT);
+
+  const TURBO_JSON = new FileGeneratorImp(
+    'turbo.json',
+    JSON.stringify(
+      {
+        tasks: {
+          build: {
+            dependsOn: ['^build'],
+            outputs: ['dist/**'],
+          },
+          lint: {},
+          test: {},
+        },
+      },
+      null,
+      2,
+    ),
+  );
+
+  return new PackageGenerator(
+    directory,
+    new PackageJsonGenerator(packageJsonModel, ''),
+    [PNPM_WORKSPACE, GITIGNORE, TURBO_JSON],
+  );
+}
+
+const GITIGNORE_CONTENT = `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite logs files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+
+.turbo
+`;