@yahoo/uds-create-loader 2.25.0 → 2.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-loader",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "type": "module",
   "private": false,
   "files": [
@@ -38,7 +38,7 @@
     "test:update": "bun test src/ --update-snapshots"
   },
   "dependencies": {
-    "@yahoo/uds-create-config": "2.25.0",
+    "@yahoo/uds-create-config": "2.26.0",
     "@babel/parser": "^7.29.0",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",

package/src/next.test.ts

@@ -0,0 +1,169 @@
+import { afterAll, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { withUds } from './next';
+
+// Repo rule: test artifacts under the package's dist/.test-tmp.
+const TMP = path.join(import.meta.dir, '../dist/.test-tmp/next-registry-deps');
+
+const REGISTRY_REL = 'src/uds/registry';
+
+function writeFixture(args: {
+  registryDeps?: Record<string, string>;
+  consumerHas?: string[];
+  buildOptions?: { componentsDir?: string; registryDir?: string };
+}): string {
+  const root = path.join(TMP, `proj-${Math.random().toString(36).slice(2, 8)}`);
+
+  mkdirSync(path.join(root, '.uds'), { recursive: true });
+  writeFileSync(
+    path.join(root, '.uds/config.json'),
+    JSON.stringify({
+      buildOptions: args.buildOptions ?? { componentsDir: 'src/uds' },
+    }),
+  );
+
+  if (args.registryDeps) {
+    const registryDir = path.join(root, REGISTRY_REL);
+    mkdirSync(path.join(registryDir, 'node_modules'), { recursive: true });
+    writeFileSync(
+      path.join(registryDir, 'package.json'),
+      JSON.stringify({
+        name: '@yahoo/uds-linked-runtime-deps',
+        private: true,
+        dependencies: args.registryDeps,
+      }),
+    );
+    for (const name of Object.keys(args.registryDeps)) {
+      const pkgDir = path.join(registryDir, 'node_modules', name);
+      mkdirSync(pkgDir, { recursive: true });
+      writeFileSync(
+        path.join(pkgDir, 'package.json'),
+        JSON.stringify({ name, version: '1.0.0', main: 'index.js' }),
+      );
+      writeFileSync(path.join(pkgDir, 'index.js'), 'module.exports = {};\n');
+    }
+  }
+
+  for (const name of args.consumerHas ?? []) {
+    const pkgDir = path.join(root, 'node_modules', name);
+    mkdirSync(pkgDir, { recursive: true });
+    writeFileSync(
+      path.join(pkgDir, 'package.json'),
+      JSON.stringify({ name, version: '9.9.9', main: 'index.js' }),
+    );
+    writeFileSync(path.join(pkgDir, 'index.js'), 'module.exports = {};\n');
+  }
+
+  return root;
+}
+
+function applyIn<T>(root: string, fn: () => T): T {
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    return fn();
+  } finally {
+    process.chdir(prev);
+  }
+}
+
+type WebpackFn = (
+  config: Record<string, unknown>,
+  options: { dev: boolean },
+) => Record<string, unknown>;
+
+beforeEach(() => {
+  rmSync(TMP, { recursive: true, force: true });
+  mkdirSync(TMP, { recursive: true });
+});
+
+afterAll(() => {
+  rmSync(TMP, { recursive: true, force: true });
+});
+
+describe('withUds — linked-registry dependency resolution', () => {
+  it('aliases registry deps for Turbopack when the consumer lacks them', () => {
+    const root = writeFixture({ registryDeps: { 'date-fns': '^4.1.0' } });
+
+    const config = applyIn(root, () => withUds({}));
+
+    const aliases = (config as { turbopack?: { resolveAlias?: unknown } })
+      .turbopack?.resolveAlias as Record<string, string>;
+    expect(aliases['date-fns']).toBe(`./${REGISTRY_REL}/node_modules/date-fns`);
+  });
+
+  it('prefers the consumer install — no alias when the consumer has the package', () => {
+    const root = writeFixture({
+      registryDeps: { 'date-fns': '^4.1.0' },
+      consumerHas: ['date-fns'],
+    });
+
+    const config = applyIn(root, () => withUds({}));
+
+    const aliases = (config as { turbopack?: { resolveAlias?: unknown } })
+      .turbopack?.resolveAlias as Record<string, string> | undefined;
+    expect(aliases?.['date-fns']).toBeUndefined();
+  });
+
+  it('appends the registry node_modules to webpack resolve.modules', () => {
+    const root = writeFixture({ registryDeps: { 'date-fns': '^4.1.0' } });
+
+    const config = applyIn(root, () => withUds({}));
+    const webpack = (config as { webpack: WebpackFn }).webpack;
+    const out = applyIn(root, () =>
+      webpack({ module: { rules: [] } }, { dev: false }),
+    );
+
+    const modules = (out as { resolve?: { modules?: string[] } }).resolve
+      ?.modules;
+    expect(modules).toBeDefined();
+    // Walk-up ('node_modules') stays first so the consumer install wins.
+    expect(modules?.[0]).toBe('node_modules');
+    expect(modules).toContain(path.join(root, REGISTRY_REL, 'node_modules'));
+  });
+
+  it('is a no-op without a generated registry manifest', () => {
+    const root = writeFixture({});
+
+    const config = applyIn(root, () => withUds({}));
+
+    const aliases = (config as { turbopack?: { resolveAlias?: unknown } })
+      .turbopack?.resolveAlias as Record<string, string> | undefined;
+    expect(aliases ?? {}).toEqual({});
+
+    const webpack = (config as { webpack: WebpackFn }).webpack;
+    const out = applyIn(root, () =>
+      webpack({ module: { rules: [] } }, { dev: false }),
+    );
+    expect(
+      (out as { resolve?: { modules?: string[] } }).resolve?.modules,
+    ).toBeUndefined();
+  });
+
+  it('honors a custom buildOptions.registryDir', () => {
+    const root = writeFixture({
+      registryDeps: { clsx: '^2.0.0' },
+      buildOptions: { registryDir: 'src/uds/registry' },
+    });
+
+    const config = applyIn(root, () => withUds({}));
+
+    const aliases = (config as { turbopack?: { resolveAlias?: unknown } })
+      .turbopack?.resolveAlias as Record<string, string>;
+    expect(aliases.clsx).toBe('./src/uds/registry/node_modules/clsx');
+  });
+
+  it('preserves caller-provided resolveAlias entries', () => {
+    const root = writeFixture({ registryDeps: { 'date-fns': '^4.1.0' } });
+
+    const config = applyIn(root, () =>
+      withUds({ turbopack: { resolveAlias: { lodash: 'lodash-es' } } }),
+    );
+
+    const aliases = (config as { turbopack?: { resolveAlias?: unknown } })
+      .turbopack?.resolveAlias as Record<string, string>;
+    expect(aliases.lodash).toBe('lodash-es');
+    expect(aliases['date-fns']).toBe(`./${REGISTRY_REL}/node_modules/date-fns`);
+  });
+});

package/src/next.ts

@@ -1,4 +1,6 @@
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
+import { resolveRegistryDir } from '@yahoo/uds-create-config';
 import type { NextConfig } from 'next';
 
 export interface WithUdsOptions {
@@ -10,7 +12,82 @@ export interface WithUdsOptions {
 }
 
 function resolveLoaderPath(): string {
-  return require.resolve('@yahoo/uds-create-loader/loader');
+  try {
+    return require.resolve('@yahoo/uds-create-loader/loader');
+  } catch {
+    // Monorepo source context (tests, pre-build) — dist/ isn't built yet, so
+    // the subpath export can't resolve. The sibling source serves the same
+    // role; a published install always resolves the dist export above.
+    return path.join(import.meta.dirname, 'loader.ts');
+  }
+}
+
+/** The linked registry's install root + dep names, read from the manifest
+ *  `uds pull` generates. Null when the project has no linked runtime deps. */
+function readRegistryDeps(
+  outputDir: string,
+): { registryDirRel: string; nodeModules: string; deps: string[] } | null {
+  let buildOptions:
+    | { componentsDir?: string; registryDir?: string }
+    | undefined;
+  try {
+    buildOptions = (
+      JSON.parse(
+        readFileSync(
+          path.resolve(process.cwd(), outputDir, 'config.json'),
+          'utf-8',
+        ),
+      ) as { buildOptions?: typeof buildOptions }
+    ).buildOptions;
+  } catch {
+    return null;
+  }
+
+  const registryDirRel = resolveRegistryDir(buildOptions);
+
+  let deps: string[];
+  try {
+    const manifest = JSON.parse(
+      readFileSync(
+        path.resolve(process.cwd(), registryDirRel, 'package.json'),
+        'utf-8',
+      ),
+    ) as { dependencies?: Record<string, string> };
+    deps = Object.keys(manifest.dependencies ?? {});
+  } catch {
+    return null;
+  }
+
+  if (deps.length === 0) return null;
+
+  const nodeModules = path.resolve(
+    process.cwd(),
+    registryDirRel,
+    'node_modules',
+  );
+  if (!existsSync(nodeModules)) return null;
+
+  return { registryDirRel, nodeModules, deps };
+}
+
+/** Turbopack has no resolve.modules equivalent, so alias each registry dep
+ *  to its installed path — only when the consumer's own install lacks it
+ *  (the consumer's version must always win). */
+function buildRegistryAliasMap(
+  registry: NonNullable<ReturnType<typeof readRegistryDeps>>,
+): Record<string, string> {
+  const aliases: Record<string, string> = {};
+
+  for (const dep of registry.deps) {
+    const consumerCopy = path.resolve(process.cwd(), 'node_modules', dep);
+    if (existsSync(consumerCopy)) continue;
+
+    if (existsSync(path.join(registry.nodeModules, dep))) {
+      aliases[dep] = `./${registry.registryDirRel}/node_modules/${dep}`;
+    }
+  }
+
+  return aliases;
 }
 
 type NextConfigFn = (
@@ -55,10 +132,24 @@ function applyUds(
     }
   }
 
+  // Linked-system runtime deps live in `<registryDir>/node_modules` (written
+  // by `uds pull`), off the walk-up path of the downleveled `.uds` modules
+  // that import them.
+  const registry = readRegistryDeps(outputDir);
+  const registryAliases = registry ? buildRegistryAliasMap(registry) : {};
+
   return {
     ...nextConfig,
     turbopack: {
       ...turbopack,
+      ...(Object.keys(registryAliases).length > 0
+        ? {
+            resolveAlias: {
+              ...registryAliases,
+              ...turbopack.resolveAlias,
+            },
+          }
+        : {}),
       rules: {
         ...existingRules,
         ...udsRules,
@@ -79,6 +170,15 @@ function applyUds(
         ],
       });
 
+      if (registry) {
+        config.resolve ??= {};
+        // 'node_modules' first: standard walk-up wins, registry is fallback.
+        config.resolve.modules ??= ['node_modules'];
+        if (!config.resolve.modules.includes(registry.nodeModules)) {
+          config.resolve.modules.push(registry.nodeModules);
+        }
+      }
+
       if (skipWatch) {
         const existing = config.watchOptions?.ignored;
         config.watchOptions = {