create-checkstack-plugin 0.1.0

package/src/scaffold-standalone.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  scaffoldStandaloneWorkspace,
+  localSiblingNames,
+} from "./scaffold-standalone";
+import { createNpmViewResolver } from "./npm-view-resolver";
+
+const tmpDirs: string[] = [];
+
+function makeTmpDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ccp-standalone-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function readPkg(file: string): Record<string, unknown> {
+  return JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+}
+
+/** A resolver that pins every published @checkstack/* dep to a fixed version. */
+function fixedResolver(baseName: string, packageScope: string) {
+  return createNpmViewResolver({
+    runNpmView: ({ packageName }) =>
+      Promise.resolve({ version: `9.9.9-${packageName.length}` }),
+    localSiblings: localSiblingNames({ baseName, packageScope }),
+  });
+}
+
+describe("localSiblingNames", () => {
+  it("builds scoped sibling names", () => {
+    expect(localSiblingNames({ baseName: "widget", packageScope: "acme" })).toEqual(
+      new Set(["@acme/widget-common", "@acme/widget-backend", "@acme/widget-frontend"]),
+    );
+  });
+
+  it("builds unscoped sibling names", () => {
+    expect(localSiblingNames({ baseName: "widget", packageScope: "" })).toEqual(
+      new Set(["widget-common", "widget-backend", "widget-frontend"]),
+    );
+  });
+});
+
+describe("scaffoldStandaloneWorkspace — layout", () => {
+  it("emits a root workspace + the trio under packages/", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "acme",
+      resolveVersion: fixedResolver("widget", "acme"),
+    });
+
+    expect(fs.existsSync(path.join(root, "package.json"))).toBe(true);
+    expect(fs.existsSync(path.join(root, "tsconfig.json"))).toBe(true);
+    expect(fs.existsSync(path.join(root, "eslint.config.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(root, ".gitignore"))).toBe(true);
+    expect(fs.existsSync(path.join(root, "README.md"))).toBe(true);
+    expect(fs.existsSync(path.join(root, ".changeset", "config.json"))).toBe(true);
+
+    for (const type of ["common", "backend", "frontend"]) {
+      expect(
+        fs.existsSync(path.join(root, "packages", `widget-${type}`, "package.json")),
+      ).toBe(true);
+    }
+  });
+
+  it("makes the root a private Bun workspace with forwarding scripts", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "acme",
+      resolveVersion: fixedResolver("widget", "acme"),
+    });
+
+    const pkg = readPkg(path.join(root, "package.json"));
+    expect(pkg.private).toBe(true);
+    expect(pkg.workspaces).toEqual(["packages/*"]);
+    const scripts = pkg.scripts as Record<string, string>;
+    expect(scripts.dev).toContain("@acme/widget-backend");
+    expect(scripts.pack).toContain("--bundle");
+  });
+});
+
+describe("scaffoldStandaloneWorkspace — versions", () => {
+  it("rewrites every published @checkstack/* dep to a concrete version", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "acme",
+      resolveVersion: fixedResolver("widget", "acme"),
+    });
+
+    const backend = readPkg(
+      path.join(root, "packages", "widget-backend", "package.json"),
+    );
+    const deps = backend.dependencies as Record<string, string>;
+    const devDeps = backend.devDependencies as Record<string, string>;
+    // A published @checkstack/* dep is now a concrete caret.
+    expect(deps["@checkstack/common"]).toMatch(/^\^9\.9\.9/);
+    expect(devDeps["@checkstack/scripts"]).toMatch(/^\^9\.9\.9/);
+  });
+
+  it("leaves the local trio siblings as workspace:* and no published workspace:* survives", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "acme",
+      resolveVersion: fixedResolver("widget", "acme"),
+    });
+
+    const backend = readPkg(
+      path.join(root, "packages", "widget-backend", "package.json"),
+    );
+    const deps = backend.dependencies as Record<string, string>;
+    // The local common sibling stays a workspace range (installs locally).
+    expect(deps["@acme/widget-common"]).toBe("workspace:*");
+
+    // No @checkstack/* (published) range is left as workspace:* in any
+    // trio package.
+    for (const type of ["common", "backend", "frontend"]) {
+      const pkg = readPkg(
+        path.join(root, "packages", `widget-${type}`, "package.json"),
+      );
+      const sections = ["dependencies", "devDependencies", "peerDependencies"];
+      for (const section of sections) {
+        const block = pkg[section] as Record<string, string> | undefined;
+        if (!block) continue;
+        for (const [name, range] of Object.entries(block)) {
+          if (name.startsWith("@checkstack/")) {
+            expect(range.startsWith("workspace:")).toBe(false);
+          }
+        }
+      }
+    }
+  });
+});
+
+describe("scaffoldStandaloneWorkspace — bundle emission", () => {
+  it("sets checkstack.bundle on the backend listing the scoped siblings", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "acme",
+      resolveVersion: fixedResolver("widget", "acme"),
+    });
+
+    const backend = readPkg(
+      path.join(root, "packages", "widget-backend", "package.json"),
+    );
+    const checkstack = backend.checkstack as { bundle?: string[] };
+    expect(checkstack.bundle).toEqual([
+      "@acme/widget-common",
+      "@acme/widget-frontend",
+    ]);
+  });
+
+  it("does NOT set checkstack.bundle on the common/frontend siblings", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "",
+      resolveVersion: fixedResolver("widget", ""),
+    });
+
+    for (const type of ["common", "frontend"]) {
+      const pkg = readPkg(
+        path.join(root, "packages", `widget-${type}`, "package.json"),
+      );
+      const checkstack = pkg.checkstack as { bundle?: unknown };
+      expect(checkstack.bundle).toBeUndefined();
+    }
+  });
+
+  it("emits unscoped sibling bundle names when no scope is given", async () => {
+    const root = makeTmpDir();
+    await scaffoldStandaloneWorkspace({
+      rootDir: root,
+      baseName: "widget",
+      description: "Widget plugin",
+      packageScope: "",
+      resolveVersion: fixedResolver("widget", ""),
+    });
+
+    const backend = readPkg(
+      path.join(root, "packages", "widget-backend", "package.json"),
+    );
+    expect(backend.name).toBe("widget-backend");
+    const checkstack = backend.checkstack as { bundle?: string[] };
+    expect(checkstack.bundle).toEqual(["widget-common", "widget-frontend"]);
+  });
+});

package/src/scaffold-standalone.ts

@@ -0,0 +1,104 @@
+import path from "node:path";
+import {
+  scaffoldPlugin,
+  scaffoldStandaloneRoot,
+  type VersionResolver,
+  type ScaffoldIo,
+} from "@checkstack/scripts/scaffold";
+
+/**
+ * Compose the full standalone plugin workspace: the root workspace files
+ * plus the `common` + `backend` + `frontend` trio under `packages/`.
+ *
+ * This is the monorepo-decoupled orchestration the `create-checkstack-plugin`
+ * CLI runs (the CLI itself only adds prompts + `git init` on top). It is a
+ * thin composition over the `@checkstack/scripts` engine seams so it can be
+ * unit-tested against a tmpdir with an injected resolver and IO.
+ */
+
+/** The three package types the standalone default emits, in dependency order. */
+export const STANDALONE_PLUGIN_TYPES = [
+  "common",
+  "backend",
+  "frontend",
+] as const;
+
+export type StandalonePluginType = (typeof STANDALONE_PLUGIN_TYPES)[number];
+
+export interface ScaffoldStandaloneWorkspaceOptions {
+  /** Repo root directory to create (the workspace root). */
+  rootDir: string;
+  /** Bare base name, e.g. `widget`. */
+  baseName: string;
+  description: string;
+  /** npm scope without `@` (e.g. `acme`); empty string for unscoped. */
+  packageScope: string;
+  /**
+   * Resolves concrete versions for the rendered `workspace:*` ranges.
+   * `@checkstack/*` deps resolve from the registry; local trio siblings are
+   * kept as `workspace:*` by the resolver.
+   */
+  resolveVersion: VersionResolver;
+  io?: Partial<ScaffoldIo>;
+}
+
+export interface ScaffoldStandaloneWorkspaceResult {
+  rootDir: string;
+  packagesDir: string;
+  /** Absolute paths of every file written (root + trio). */
+  createdFiles: string[];
+}
+
+/**
+ * Build the set of local sibling package names (scope-aware) so the version
+ * resolver knows which `workspace:*` ranges to leave untouched.
+ */
+export function localSiblingNames({
+  baseName,
+  packageScope,
+}: {
+  baseName: string;
+  packageScope: string;
+}): Set<string> {
+  const prefix = packageScope ? `@${packageScope}/` : "";
+  return new Set(
+    STANDALONE_PLUGIN_TYPES.map((type) => `${prefix}${baseName}-${type}`),
+  );
+}
+
+export async function scaffoldStandaloneWorkspace({
+  rootDir,
+  baseName,
+  description,
+  packageScope,
+  resolveVersion,
+  io,
+}: ScaffoldStandaloneWorkspaceOptions): Promise<ScaffoldStandaloneWorkspaceResult> {
+  const createdFiles: string[] = [];
+
+  const root = scaffoldStandaloneRoot({
+    rootDir,
+    baseName,
+    description,
+    packageScope,
+    io,
+  });
+  createdFiles.push(...root.createdFiles);
+
+  const packagesDir = path.join(rootDir, "packages");
+
+  for (const pluginType of STANDALONE_PLUGIN_TYPES) {
+    const result = await scaffoldPlugin({
+      mode: { kind: "standalone", targetDir: packagesDir },
+      baseName,
+      description,
+      pluginType,
+      packageScope,
+      resolveVersion,
+      io,
+    });
+    createdFiles.push(...result.createdFiles);
+  }
+
+  return { rootDir, packagesDir, createdFiles };
+}