@jay-framework/compiler-jay-stack 0.10.0 → 0.12.0

package/dist/index.d.ts

@@ -108,6 +108,93 @@ declare function transformActionImports(code: string, id: string, resolveActionM
     code: string;
 } | null>): Promise<TransformResult | null>;
 
+/**
+ * Plugin Client Import Resolver
+ *
+ * Transforms imports from Jay plugin packages to use their /client subpath
+ * when in client build mode.
+ *
+ * This handles transitive plugin dependencies: when wix-stores imports from
+ * wix-server-client, the import should be rewritten to wix-server-client/client
+ * in client builds.
+ *
+ * Uses a `transform` hook instead of `resolveId` to ensure the rewrite happens
+ * before rollup's `external` option is evaluated.
+ *
+ * Detection:
+ * 1. Check if the imported package has a plugin.yaml (is a Jay plugin)
+ * 2. Check if the package exports a /client subpath
+ * 3. If both true, rewrite the import to use /client
+ */
+
+/**
+ * Interface for detecting if a package is a Jay plugin with /client export.
+ * Extracted to allow mocking in tests.
+ */
+interface PluginDetector {
+    /**
+     * Checks if a package is a Jay plugin with a /client export.
+     * @param packageName - The package name (e.g., '@jay-framework/wix-stores')
+     * @param projectRoot - The project root for resolution
+     * @returns true if the package should be rewritten to /client
+     */
+    isJayPluginWithClientExport(packageName: string, projectRoot: string): boolean;
+}
+/**
+ * Default implementation using Node's require.resolve.
+ */
+declare function createDefaultPluginDetector(): PluginDetector;
+/**
+ * Extracts the package name from an import source.
+ * Handles scoped packages like @jay-framework/wix-stores.
+ */
+declare function extractPackageName(source: string): string | null;
+/**
+ * Checks if the import is already using a subpath (not just the main entry).
+ */
+declare function isSubpathImport(source: string, packageName: string): boolean;
+interface TransformImportsOptions {
+    /** The source code to transform */
+    code: string;
+    /** Project root for plugin detection */
+    projectRoot: string;
+    /** File path for logging */
+    filePath: string;
+    /** Plugin detector (injectable for testing) */
+    pluginDetector: PluginDetector;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+interface TransformImportsResult {
+    /** The transformed code */
+    code: string;
+    /** Whether any changes were made */
+    hasChanges: boolean;
+}
+/**
+ * Transforms import/export declarations in source code.
+ * Rewrites plugin package imports to use /client subpath.
+ *
+ * This is a pure function - all IO is handled by the pluginDetector.
+ */
+declare function transformImports(options: TransformImportsOptions): TransformImportsResult;
+interface PluginClientImportResolverOptions {
+    /** Project root directory for resolution */
+    projectRoot?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Custom plugin detector (for testing) */
+    pluginDetector?: PluginDetector;
+}
+/**
+ * Creates a Vite plugin that transforms plugin package imports to /client
+ * in client builds.
+ *
+ * Uses the `transform` hook to rewrite import declarations before rollup's
+ * external option is evaluated.
+ */
+declare function createPluginClientImportResolver(options?: PluginClientImportResolverOptions): Plugin;
+
 interface JayStackCompilerOptions extends JayRollupConfig {
     /**
      * Enable import chain tracking for debugging server code leaking into client builds.
@@ -156,4 +243,4 @@ interface JayStackCompilerOptions extends JayRollupConfig {
  */
 declare function jayStackCompiler(options?: JayStackCompilerOptions): Plugin[];
 
-export { type ActionMetadata, type BuildEnvironment, type ExtractedActions, type ImportChainTrackerOptions, type JayStackCompilerOptions, clearActionMetadataCache, createImportChainTracker, extractActionsFromSource, isActionImport, jayStackCompiler, transformActionImports, transformJayStackBuilder };
+export { type ActionMetadata, type BuildEnvironment, type ExtractedActions, type ImportChainTrackerOptions, type JayStackCompilerOptions, type PluginClientImportResolverOptions, type PluginDetector, type TransformImportsOptions, type TransformImportsResult, clearActionMetadataCache, createDefaultPluginDetector, createImportChainTracker, createPluginClientImportResolver, extractActionsFromSource, extractPackageName, isActionImport, isSubpathImport, jayStackCompiler, transformActionImports, transformImports, transformJayStackBuilder };

package/dist/index.js

@@ -1,8 +1,10 @@
 import { jayRuntime } from "@jay-framework/vite-plugin";
 import tsBridge from "@jay-framework/typescript-bridge";
 import { flattenVariable, isImportModuleVariableRoot, mkTransformer, SourceFileBindingResolver, areFlattenedAccessChainsEqual } from "@jay-framework/compiler";
-import * as fs from "node:fs";
+import { getLogger } from "@jay-framework/logger";
 import * as path from "node:path";
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
 const COMPONENT_SERVER_METHODS = /* @__PURE__ */ new Set([
   "withServices",
   "withLoadParams",
@@ -387,7 +389,7 @@ async function transformActionImports(code, id, resolveActionModule) {
   for (const imp of actionImports) {
     const resolved = await resolveActionModule(imp.source, id);
     if (!resolved) {
-      console.warn(`[action-transform] Could not resolve action module: ${imp.source}`);
+      getLogger().warn(`[action-transform] Could not resolve action module: ${imp.source}`);
       continue;
     }
     const actions = extractActionsFromSource(resolved.code, resolved.path);
@@ -400,7 +402,7 @@ async function transformActionImports(code, id, resolveActionModule) {
         );
         needsCreateActionCallerImport = true;
       } else {
-        console.warn(
+        getLogger().warn(
           `[action-transform] Export '${importName}' from ${imp.source} is not a recognized action`
         );
       }
@@ -504,7 +506,7 @@ function createImportChainTracker(options = {}) {
       importChain.clear();
       detectedServerModules.clear();
       if (verbose) {
-        console.log("[import-chain-tracker] Build started, tracking imports...");
+        getLogger().info("[import-chain-tracker] Build started, tracking imports...");
       }
     },
     resolveId(source, importer, options2) {
@@ -516,7 +518,7 @@ function createImportChainTracker(options = {}) {
       }
       if (importer) {
         if (verbose) {
-          console.log(
+          getLogger().info(
             `[import-chain-tracker] ${shortenPath(importer)} imports ${source}`
           );
         }
@@ -533,14 +535,14 @@ function createImportChainTracker(options = {}) {
       if (isServerOnlyModule(id)) {
         detectedServerModules.add(id);
         const chain = buildImportChain(id);
-        console.error(
+        getLogger().error(
           `
 [import-chain-tracker] ⚠️  Server-only module detected in client build!`
         );
-        console.error(`Module: ${shortenPath(id)}`);
-        console.error(`Import chain:`);
-        console.error(formatChain(chain));
-        console.error("");
+        getLogger().error(`Module: ${shortenPath(id)}`);
+        getLogger().error(`Import chain:`);
+        getLogger().error(formatChain(chain));
+        getLogger().error("");
       }
       const importRegex = /import\s+(?:(?:\{[^}]*\}|[^{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
       let match;
@@ -550,16 +552,18 @@ function createImportChainTracker(options = {}) {
         if (isServerOnlyModule(importedModule)) {
           if (!detectedServerModules.has(importedModule)) {
             detectedServerModules.add(importedModule);
-            console.error(
+            getLogger().error(
               `
 [import-chain-tracker] ⚠️  Server-only import detected in client build!`
             );
-            console.error(`Module "${importedModule}" imported by: ${shortenPath(id)}`);
+            getLogger().error(
+              `Module "${importedModule}" imported by: ${shortenPath(id)}`
+            );
             const chain = buildImportChain(id);
             chain.push(importedModule);
-            console.error(`Import chain:`);
-            console.error(formatChain(chain));
-            console.error("");
+            getLogger().error(`Import chain:`);
+            getLogger().error(formatChain(chain));
+            getLogger().error("");
           }
         }
       }
@@ -567,27 +571,151 @@ function createImportChainTracker(options = {}) {
     },
     buildEnd() {
       if (detectedServerModules.size > 0) {
-        console.warn(
+        getLogger().warn(
           `
 [import-chain-tracker] ⚠️  ${detectedServerModules.size} server-only module(s) detected during transform:`
         );
         for (const mod of detectedServerModules) {
-          console.warn(`  - ${mod}`);
+          getLogger().warn(`  - ${mod}`);
         }
-        console.warn(
+        getLogger().warn(
           "\nNote: These may be stripped by the code-split transform if only used in .withServer()."
         );
-        console.warn(
+        getLogger().warn(
           'If build fails with "not exported" errors, check the import chains above.\n'
         );
       } else if (verbose) {
-        console.log(
+        getLogger().info(
           "[import-chain-tracker] ✅ No server-only modules detected in client build"
         );
       }
     }
   };
 }
+const require2 = createRequire(import.meta.url);
+function createDefaultPluginDetector() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    isJayPluginWithClientExport(packageName, projectRoot) {
+      const cacheKey = `${packageName}:${projectRoot}`;
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      let result = false;
+      try {
+        require2.resolve(`${packageName}/plugin.yaml`, { paths: [projectRoot] });
+        try {
+          require2.resolve(`${packageName}/client`, { paths: [projectRoot] });
+          result = true;
+        } catch {
+          result = false;
+        }
+      } catch {
+        result = false;
+      }
+      cache.set(cacheKey, result);
+      return result;
+    }
+  };
+}
+function extractPackageName(source) {
+  if (source.startsWith(".") || source.startsWith("/")) {
+    return null;
+  }
+  if (source.startsWith("@")) {
+    const parts2 = source.split("/");
+    if (parts2.length >= 2) {
+      return `${parts2[0]}/${parts2[1]}`;
+    }
+    return null;
+  }
+  const parts = source.split("/");
+  return parts[0];
+}
+function isSubpathImport(source, packageName) {
+  return source.length > packageName.length && source[packageName.length] === "/";
+}
+const IMPORT_REGEX = /import\s+(.+?)\s+from\s+(['"])([^'"]+)\2/g;
+const EXPORT_FROM_REGEX = /export\s+(.+?)\s+from\s+(['"])([^'"]+)\2/g;
+function transformImports(options) {
+  const { code, projectRoot, filePath, pluginDetector, verbose = false } = options;
+  let hasChanges = false;
+  let result = code;
+  result = result.replace(IMPORT_REGEX, (match, clause, quote, source) => {
+    const packageName = extractPackageName(source);
+    if (!packageName)
+      return match;
+    if (isSubpathImport(source, packageName))
+      return match;
+    if (!pluginDetector.isJayPluginWithClientExport(packageName, projectRoot))
+      return match;
+    hasChanges = true;
+    const newSource = `${packageName}/client`;
+    if (verbose) {
+      getLogger().info(
+        `[plugin-client-import] Rewriting import ${source} -> ${newSource} (in ${path.basename(filePath)})`
+      );
+    }
+    return `import ${clause} from ${quote}${newSource}${quote}`;
+  });
+  result = result.replace(EXPORT_FROM_REGEX, (match, clause, quote, source) => {
+    const packageName = extractPackageName(source);
+    if (!packageName)
+      return match;
+    if (isSubpathImport(source, packageName))
+      return match;
+    if (!pluginDetector.isJayPluginWithClientExport(packageName, projectRoot))
+      return match;
+    hasChanges = true;
+    const newSource = `${packageName}/client`;
+    if (verbose) {
+      getLogger().info(
+        `[plugin-client-import] Rewriting export ${source} -> ${newSource} (in ${path.basename(filePath)})`
+      );
+    }
+    return `export ${clause} from ${quote}${newSource}${quote}`;
+  });
+  return { code: result, hasChanges };
+}
+function createPluginClientImportResolver(options = {}) {
+  const { verbose = false } = options;
+  let projectRoot = options.projectRoot || process.cwd();
+  let isSSRBuild = false;
+  const pluginDetector = options.pluginDetector || createDefaultPluginDetector();
+  return {
+    name: "jay-stack:plugin-client-import",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root || projectRoot;
+      isSSRBuild = !!config.build?.ssr;
+    },
+    transform(code, id, transformOptions) {
+      if (transformOptions?.ssr || isSSRBuild) {
+        return null;
+      }
+      if (!id.endsWith(".ts") && !id.endsWith(".js") && !id.includes(".ts?") && !id.includes(".js?")) {
+        return null;
+      }
+      if (id.includes("node_modules") && !id.includes("@jay-framework")) {
+        return null;
+      }
+      if (!code.includes("@jay-framework/") && !code.includes("from '@") && !code.includes('from "@')) {
+        return null;
+      }
+      const result = transformImports({
+        code,
+        projectRoot,
+        filePath: id,
+        pluginDetector,
+        verbose
+      });
+      if (!result.hasChanges) {
+        return null;
+      }
+      return { code: result.code };
+    }
+  };
+}
 function jayStackCompiler(options = {}) {
   const { trackImports, ...jayOptions } = options;
   const moduleCache = /* @__PURE__ */ new Map();
@@ -597,6 +725,7 @@ function jayStackCompiler(options = {}) {
   if (shouldTrackImports) {
     plugins.push(createImportChainTracker(trackerOptions));
   }
+  plugins.push(createPluginClientImportResolver({ verbose: !!shouldTrackImports }));
   plugins.push(
     // First: Jay Stack code splitting transformation
     {
@@ -616,7 +745,7 @@ function jayStackCompiler(options = {}) {
         try {
           return transformJayStackBuilder(code, id, environment);
         } catch (error) {
-          console.error(`[jay-stack:code-split] Error transforming ${id}:`, error);
+          getLogger().error(`[jay-stack:code-split] Error transforming ${id}: ${error}`);
           return null;
         }
       }
@@ -657,6 +786,13 @@ function jayStackCompiler(options = {}) {
             } else {
               return null;
             }
+          } else if (resolvedPath.endsWith(".js") && !fs.existsSync(resolvedPath)) {
+            const tsPath = resolvedPath.slice(0, -3) + ".ts";
+            if (fs.existsSync(tsPath)) {
+              resolvedPath = tsPath;
+            } else {
+              return null;
+            }
           }
           return `\0jay-action:${resolvedPath}`;
         },
@@ -669,12 +805,14 @@ function jayStackCompiler(options = {}) {
           try {
             code = await fs.promises.readFile(actualPath, "utf-8");
           } catch (err) {
-            console.error(`[action-transform] Could not read ${actualPath}:`, err);
+            getLogger().error(
+              `[action-transform] Could not read ${actualPath}: ${err}`
+            );
             return null;
           }
           const actions = extractActionsFromSource(code, actualPath);
           if (actions.length === 0) {
-            console.warn(`[action-transform] No actions found in ${actualPath}`);
+            getLogger().warn(`[action-transform] No actions found in ${actualPath}`);
             return null;
           }
           const lines = [
@@ -703,10 +841,15 @@ function jayStackCompiler(options = {}) {
 }
 export {
   clearActionMetadataCache,
+  createDefaultPluginDetector,
   createImportChainTracker,
+  createPluginClientImportResolver,
   extractActionsFromSource,
+  extractPackageName,
   isActionImport,
+  isSubpathImport,
   jayStackCompiler,
   transformActionImports,
+  transformImports,
   transformJayStackBuilder
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/compiler-jay-stack",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -27,15 +27,16 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/compiler": "^0.10.0",
-    "@jay-framework/compiler-shared": "^0.10.0",
-    "@jay-framework/typescript-bridge": "^0.5.0",
-    "@jay-framework/vite-plugin": "^0.10.0",
+    "@jay-framework/compiler": "^0.12.0",
+    "@jay-framework/compiler-shared": "^0.12.0",
+    "@jay-framework/logger": "^0.12.0",
+    "@jay-framework/typescript-bridge": "^0.7.0",
+    "@jay-framework/vite-plugin": "^0.12.0",
     "typescript": "^5.3.3",
     "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.10.0",
+    "@jay-framework/dev-environment": "^0.12.0",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",
     "vitest": "^1.2.1"