@cosmicdrift/kumiko-framework 0.374.0 → 0.377.0

package/src/scripts/codemod/package-merge.ts

@@ -0,0 +1,260 @@
+#!/usr/bin/env bun
+// package-merge — packages folded into another package keep working as shims for one wave and are
+// then removed; this rewrites the consumer side of each move:
+//   import/export/import()/mock.module specifiers (incl. subpaths) -> the new specifier
+//   CSS @import/@plugin/@config specifiers                         -> the new specifier
+//   package.json dependencies/devDependencies/peerDependencies     -> old entry out, new entry in
+//     (same version range, same block, skipped when the block already has it)
+// New moves are rows in PACKAGE_MERGE_MAPPINGS; nothing else changes.
+//
+// Usage:
+//   bun scripts/codemod/package-merge.ts <targetDir...> [--check | --dry-run | --write] [--no-format]
+// Without a mode flag it writes (kumiko-upgrade --apply calls it that way). --check exits 1
+// while any rewritable site is left; --dry-run only reports.
+
+import { Node, Project } from "ts-morph";
+import {
+  applyEdits,
+  type CodemodResult,
+  moduleSpecifierLiterals,
+  runCodemodCli,
+  type SiteLists,
+  type TextEdit,
+} from "./codemod-support.ts";
+
+export interface PackageMergeMapping {
+  readonly from: string;
+  readonly to: string;
+}
+
+// A `from` also matches its subpaths: `<from>/x` becomes `<to>/x`. Longer rows win over shorter ones.
+export const PACKAGE_MERGE_MAPPINGS: readonly PackageMergeMapping[] = [
+  { from: "@cosmicdrift/kumiko-http", to: "@cosmicdrift/kumiko-framework/http" },
+  {
+    from: "@cosmicdrift/kumiko-repo-manifest",
+    to: "@cosmicdrift/kumiko-guards/repo-manifest",
+  },
+  { from: "@cosmicdrift/kumiko-headless", to: "@cosmicdrift/kumiko-renderer/headless" },
+  { from: "@cosmicdrift/kumiko-dispatcher-live", to: "@cosmicdrift/kumiko-renderer/live" },
+  { from: "@cosmicdrift/kumiko-renderer-web", to: "@cosmicdrift/kumiko-renderer/web" },
+];
+
+const DEPENDENCY_BLOCKS = ["dependencies", "devDependencies", "peerDependencies"] as const;
+
+const SKIPPED_PATH_SUFFIXES: readonly string[] = [
+  "packages/http/src/index.ts",
+  "packages/repo-manifest/src/index.ts",
+  "packages/repo-manifest/src/app-ports/index.ts",
+  "packages/headless/src/index.ts",
+  "packages/headless/src/apex/index.ts",
+  "packages/headless/src/dispatcher/index.ts",
+  "packages/headless/src/locale-routing/index.ts",
+  "packages/dispatcher-live/src/index.ts",
+  "packages/renderer-web/src/index.ts",
+  "packages/renderer-web/src/theme-plugin.ts",
+  "packages/renderer-web/src/styles.css",
+  "packages/framework/src/scripts/codemod/package-merge.ts",
+  "packages/framework/src/__tests__/package-merge-codemod.test.ts",
+];
+
+function packageNameOf(specifier: string): string {
+  const [scope, name] = specifier.split("/");
+  return specifier.startsWith("@") ? `${scope}/${name}` : (scope ?? specifier);
+}
+
+function mappingsLongestFirst(mappings: readonly PackageMergeMapping[]): PackageMergeMapping[] {
+  return [...mappings].sort((a, b) => b.from.length - a.from.length);
+}
+
+export function mergedSpecifier(
+  specifier: string,
+  mappings: readonly PackageMergeMapping[] = PACKAGE_MERGE_MAPPINGS,
+): string | undefined {
+  for (const { from, to } of mappingsLongestFirst(mappings)) {
+    if (specifier === from) return to;
+    if (specifier.startsWith(`${from}/`)) return `${to}${specifier.slice(from.length)}`;
+  }
+  return undefined;
+}
+
+function movedPackages(mappings: readonly PackageMergeMapping[]): Map<string, string> {
+  const moved = new Map<string, string>();
+  for (const { from, to } of mappings) {
+    if (packageNameOf(from) === from) moved.set(from, packageNameOf(to));
+  }
+  return moved;
+}
+
+function transformTypeScriptSource(
+  source: string,
+  filePath: string,
+  mappings: readonly PackageMergeMapping[],
+  result: SiteLists,
+): string {
+  if (!mappings.some(({ from }) => source.includes(from))) return source;
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+  });
+  const sourceFile = project.createSourceFile(filePath, source);
+  const edits: TextEdit[] = [];
+  for (const literal of moduleSpecifierLiterals(sourceFile)) {
+    if (!Node.isStringLiteral(literal)) continue;
+    const current = literal.getLiteralValue();
+    const next = mergedSpecifier(current, mappings);
+    if (next === undefined) continue;
+    result.rewrites.push({
+      file: filePath,
+      line: literal.getStartLineNumber(),
+      description: `${current} -> ${next}`,
+    });
+    edits.push({ start: literal.getStart(), end: literal.getEnd(), text: JSON.stringify(next) });
+  }
+  return applyEdits(source, edits);
+}
+
+const CSS_AT_RULE_STRING = /@(import|plugin|config|source)(\s+(?:url\(\s*)?)(["'])([^"'\n]+)\3/g;
+
+// A stylesheet specifier is rewritten like an import. A path into the package's files (`@source
+// ".../node_modules/<from>/src/..."`) has no mechanical target, so it is reported as manual.
+function transformCssSource(
+  source: string,
+  filePath: string,
+  mappings: readonly PackageMergeMapping[],
+  result: SiteLists,
+): string {
+  if (!mappings.some(({ from }) => source.includes(from))) return source;
+  const lineOf = (offset: number): number => source.slice(0, offset).split("\n").length;
+  return source.replace(
+    CSS_AT_RULE_STRING,
+    (match, rule: string, between: string, quote: string, value: string, offset: number) => {
+      const next = rule === "source" ? undefined : mergedSpecifier(value, mappings);
+      if (next !== undefined) {
+        result.rewrites.push({
+          file: filePath,
+          line: lineOf(offset),
+          description: `${value} -> ${next}`,
+        });
+        return `@${rule}${between}${quote}${next}${quote}`;
+      }
+      if (mappings.some(({ from }) => value.includes(`/${from}/`))) {
+        result.manual.push({
+          file: filePath,
+          line: lineOf(offset),
+          description: `@${rule} path into a merged package: ${value}`,
+        });
+      }
+      return match;
+    },
+  );
+}
+
+function detectIndent(source: string): string {
+  return /^([ \t]+)"/m.exec(source)?.[1] ?? "  ";
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.values(value).every((entry) => typeof entry === "string")
+  );
+}
+
+function isSortedKeys(record: Record<string, string>): boolean {
+  const keys = Object.keys(record);
+  return keys.every((key, index) => index === 0 || (keys[index - 1] ?? "") <= key);
+}
+
+function mergeDependencyBlock(
+  block: Record<string, string>,
+  moved: ReadonlyMap<string, string>,
+  ownName: unknown,
+  describe: (description: string) => void,
+): Record<string, string> | undefined {
+  const next: Record<string, string> = {};
+  let changed = false;
+  for (const [name, range] of Object.entries(block)) {
+    const target = moved.get(name);
+    if (target === undefined) {
+      next[name] = range;
+      continue;
+    }
+    changed = true;
+    describe(`${name} -> ${target}`);
+    if (target !== ownName && !(target in block)) next[target] = range;
+  }
+  if (!changed) return undefined;
+  return isSortedKeys(block)
+    ? Object.fromEntries(Object.entries(next).sort(([a], [b]) => a.localeCompare(b)))
+    : next;
+}
+
+function transformPackageJson(
+  source: string,
+  filePath: string,
+  mappings: readonly PackageMergeMapping[],
+  result: SiteLists,
+): string {
+  let manifest: unknown;
+  try {
+    manifest = JSON.parse(source);
+  } catch {
+    result.manual.push({ file: filePath, line: 1, description: "package.json is not valid JSON" });
+    return source;
+  }
+  if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) return source;
+  const moved = movedPackages(mappings);
+  const record: Record<string, unknown> = { ...manifest };
+  let changed = false;
+  for (const blockName of DEPENDENCY_BLOCKS) {
+    const block = record[blockName];
+    if (!isStringRecord(block)) continue;
+    const merged = mergeDependencyBlock(block, moved, record["name"], (description) => {
+      result.rewrites.push({
+        file: filePath,
+        line: 1,
+        description: `${blockName}: ${description}`,
+      });
+    });
+    if (merged === undefined) continue;
+    record[blockName] = merged;
+    changed = true;
+  }
+  if (!changed) return source;
+  const trailingNewline = source.endsWith("\n") ? "\n" : "";
+  return `${JSON.stringify(record, null, detectIndent(source))}${trailingNewline}`;
+}
+
+export function transformPackageMergeSource(
+  source: string,
+  filePath = "source.ts",
+  mappings: readonly PackageMergeMapping[] = PACKAGE_MERGE_MAPPINGS,
+): CodemodResult {
+  const result: SiteLists = { rewrites: [], manual: [] };
+  const output = filePath.endsWith("package.json")
+    ? transformPackageJson(source, filePath, mappings, result)
+    : filePath.endsWith(".css")
+      ? transformCssSource(source, filePath, mappings, result)
+      : transformTypeScriptSource(source, filePath, mappings, result);
+  return { output, ...result };
+}
+
+function isSkippedPath(file: string): boolean {
+  return SKIPPED_PATH_SUFFIXES.some((suffix) => file.endsWith(suffix));
+}
+
+if (import.meta.main) {
+  await runCodemodCli(
+    {
+      name: "package-merge",
+      transform: (source, filePath) => transformPackageMergeSource(source, filePath),
+      isSkippedPath,
+      extraFileNames: ["package.json"],
+      extraExtensions: [".css"],
+    },
+    process.argv.slice(2),
+  );
+}

package/src/scripts/codemod/s3-imports.ts

@@ -10,17 +10,20 @@
 // Without a mode flag it writes (kumiko-upgrade --apply calls it that way). --check exits 1
 // while any rewritable or manual site is left; --dry-run only reports.
 
-import { type ImportDeclaration, Node, Project, type SourceFile, SyntaxKind } from "ts-morph";
+import { type ImportDeclaration, Node, Project, type SourceFile } from "ts-morph";
 import {
+  applyEdits,
   type CodemodResult,
   type CodemodSite,
   ensureNamedImport,
   hasImportBinding,
+  moduleSpecifierLiterals,
   relativeSpecifier,
   removeNamedImport,
   runCodemodCli,
   type SiteLists,
   sourceRelativeModule,
+  type TextEdit,
 } from "./codemod-support.ts";
 
 const BUNDLED_PACKAGE = "@cosmicdrift/kumiko-bundled-features";
@@ -79,47 +82,6 @@ function site(file: string, node: Node, description: string): CodemodSite {
   return { file, line: node.getStartLineNumber(), description };
 }
 
-function stringLiteralOf(node: Node | undefined): Node | undefined {
-  return node !== undefined && Node.isStringLiteral(node) ? node : undefined;
-}
-
-interface TextEdit {
-  readonly start: number;
-  readonly end: number;
-  readonly text: string;
-}
-
-function applyEdits(source: string, edits: readonly TextEdit[]): string {
-  let output = source;
-  for (const edit of [...edits].sort((x, y) => y.start - x.start)) {
-    output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
-  }
-  return output;
-}
-
-function moduleSpecifierLiterals(sourceFile: SourceFile): Node[] {
-  const literals: Node[] = [];
-  for (const declaration of [
-    ...sourceFile.getImportDeclarations(),
-    ...sourceFile.getExportDeclarations(),
-  ]) {
-    const literal = declaration.getModuleSpecifier();
-    if (literal !== undefined) literals.push(literal);
-  }
-  for (const importType of sourceFile.getDescendantsOfKind(SyntaxKind.ImportType)) {
-    const argument = importType.getArgument();
-    if (Node.isLiteralTypeNode(argument)) literals.push(argument.getLiteral());
-  }
-  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    const callee = call.getExpression();
-    const isModuleLoad =
-      callee.getKind() === SyntaxKind.ImportKeyword || callee.getText() === "mock.module";
-    const literal = stringLiteralOf(call.getArguments()[0]);
-    if (isModuleLoad && literal !== undefined) literals.push(literal);
-  }
-  return literals;
-}
-
 function rewriteLibSpecifiers(
   sourceFile: SourceFile,
   source: string,

package/src/scripts/codemod/testing-injection.ts

@@ -0,0 +1,135 @@
+#!/usr/bin/env bun
+// testing-injection — kumiko-testing no longer imports bundled-features or dev-server. The test
+// functions that need them are bound in `@cosmicdrift/kumiko-dev-server/testing`:
+//   @cosmicdrift/kumiko-testing                    { setupAppTestStack, SetupAppTestStackOptions,
+//                                                    seedTenant, persistTenantRows }
+//   @cosmicdrift/kumiko-testing/e2e/seed-route     { createE2eSeedRoutes }
+//   -> @cosmicdrift/kumiko-dev-server/testing
+// Names that stay (types like SeededTenant, E2eExtraSeeder, isE2eSeedingEnabled) keep their import.
+//
+// Usage:
+//   bun scripts/codemod/testing-injection.ts <targetDir...> [--check | --dry-run | --write] [--no-format]
+// Without a mode flag it writes (kumiko-upgrade --apply calls it that way). --check exits 1
+// while any rewritable or manual site is left; --dry-run only reports.
+
+import { type ImportDeclaration, Project, SyntaxKind } from "ts-morph";
+import {
+  type CodemodResult,
+  ensureNamedImport,
+  runCodemodCli,
+  type SiteLists,
+} from "./codemod-support.ts";
+
+const TESTING_PACKAGE = "@cosmicdrift/kumiko-testing";
+const TARGET_MODULE = "@cosmicdrift/kumiko-dev-server/testing";
+
+const MOVED_NAMES_BY_MODULE: ReadonlyMap<string, ReadonlySet<string>> = new Map([
+  [
+    TESTING_PACKAGE,
+    new Set(["setupAppTestStack", "SetupAppTestStackOptions", "seedTenant", "persistTenantRows"]),
+  ],
+  [`${TESTING_PACKAGE}/e2e/seed-route`, new Set(["createE2eSeedRoutes"])],
+]);
+
+const CHEAP_PREFILTER = /kumiko-testing/;
+const SKIPPED_PATH_SUFFIXES: readonly string[] = [
+  "packages/framework/src/scripts/codemod/testing-injection.ts",
+  "packages/framework/src/__tests__/testing-injection-codemod.test.ts",
+  "packages/dev-server/src/testing.ts",
+];
+
+function movedNamesOf(declaration: ImportDeclaration): ReadonlySet<string> | undefined {
+  return MOVED_NAMES_BY_MODULE.get(declaration.getModuleSpecifierValue());
+}
+
+function reportNamespaceUses(
+  declaration: ImportDeclaration,
+  moved: ReadonlySet<string>,
+  filePath: string,
+  result: SiteLists,
+): void {
+  const namespaceName = declaration.getNamespaceImport()?.getText();
+  const accesses =
+    namespaceName === undefined
+      ? []
+      : declaration.getSourceFile().getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+  for (const access of accesses) {
+    if (access.getExpression().getText() === namespaceName && moved.has(access.getName())) {
+      result.manual.push({
+        file: filePath,
+        line: access.getStartLineNumber(),
+        description: `${namespaceName}.${access.getName()}: import it from ${TARGET_MODULE}`,
+      });
+    }
+  }
+}
+
+export function transformTestingInjectionSource(
+  source: string,
+  filePath = "source.ts",
+): CodemodResult {
+  const result: SiteLists = { rewrites: [], manual: [] };
+  if (!CHEAP_PREFILTER.test(source)) return { output: source, ...result };
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+  });
+  const sourceFile = project.createSourceFile(filePath, source);
+  for (const declaration of sourceFile.getImportDeclarations()) {
+    const moved = movedNamesOf(declaration);
+    if (moved === undefined) continue;
+    reportNamespaceUses(declaration, moved, filePath, result);
+    const movedImports = declaration
+      .getNamedImports()
+      .filter((named) => moved.has(named.getName()));
+    if (movedImports.length === 0) continue;
+    const line = declaration.getStartLineNumber();
+    const typeOnlyDeclaration = declaration.isTypeOnly();
+    const names = movedImports.map((named) => named.getName());
+    // Collected first: removing a specifier invalidates the nodes of its siblings.
+    const snapshots = movedImports.map((named) => ({
+      name: named.getName(),
+      alias: named.getAliasNode()?.getText(),
+      typeOnly: named.isTypeOnly(),
+    }));
+    for (const named of movedImports) named.remove();
+    if (
+      declaration.getNamedImports().length === 0 &&
+      declaration.getNamespaceImport() === undefined &&
+      declaration.getDefaultImport() === undefined
+    ) {
+      declaration.remove();
+    }
+    for (const snapshot of snapshots) {
+      const typeOnly = typeOnlyDeclaration || snapshot.typeOnly;
+      if (snapshot.alias === undefined) {
+        ensureNamedImport(sourceFile, TARGET_MODULE, snapshot.name, typeOnly);
+      } else {
+        sourceFile.addImportDeclaration({
+          moduleSpecifier: TARGET_MODULE,
+          namedImports: [{ name: snapshot.name, alias: snapshot.alias }],
+          isTypeOnly: typeOnly,
+        });
+      }
+    }
+    result.rewrites.push({
+      file: filePath,
+      line,
+      description: `${names.join(", ")} -> ${TARGET_MODULE}`,
+    });
+  }
+  const output = result.rewrites.length > 0 ? sourceFile.getFullText() : source;
+  return { output, ...result };
+}
+
+function isSkippedPath(file: string): boolean {
+  return SKIPPED_PATH_SUFFIXES.some((suffix) => file.endsWith(suffix));
+}
+
+if (import.meta.main) {
+  await runCodemodCli(
+    { name: "testing-injection", transform: transformTestingInjectionSource, isSkippedPath },
+    process.argv.slice(2),
+  );
+}