@jay-framework/compiler-jay-stack 0.10.0 → 0.11.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,9 @@
 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 * 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",
@@ -588,6 +589,130 @@ function createImportChainTracker(options = {}) {
     }
   };
 }
+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) {
+      console.log(
+        `[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) {
+      console.log(
+        `[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 +722,7 @@ function jayStackCompiler(options = {}) {
   if (shouldTrackImports) {
     plugins.push(createImportChainTracker(trackerOptions));
   }
+  plugins.push(createPluginClientImportResolver({ verbose: !!shouldTrackImports }));
   plugins.push(
     // First: Jay Stack code splitting transformation
     {
@@ -657,6 +783,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}`;
         },
@@ -703,10 +836,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.11.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -27,15 +27,15 @@
     "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.11.0",
+    "@jay-framework/compiler-shared": "^0.11.0",
+    "@jay-framework/typescript-bridge": "^0.6.0",
+    "@jay-framework/vite-plugin": "^0.11.0",
     "typescript": "^5.3.3",
     "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.10.0",
+    "@jay-framework/dev-environment": "^0.11.0",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",
     "vitest": "^1.2.1"