@rainfw/core 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainfw/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A TypeScript web framework for Cloudflare Workers",
   "bin": {
     "rainjs": "./cli/index.js"
@@ -21,7 +21,8 @@
     "test:generate": "node --test tests/generate.test.js",
     "bench": "node scripts/bench.js",
     "build:pkg": "tsc -p tsconfig.build.json && node -e \"require('fs').writeFileSync('dist/package.json',JSON.stringify({type:'module'}))\"",
-    "prepublishOnly": "npm run build:pkg"
+    "prepublishOnly": "npm run build:pkg",
+    "release": "npm run ci && npm publish --access public"
   },
   "keywords": [
     "cloudflare-workers",
@@ -57,6 +58,10 @@
     "./db": {
       "types": "./dist/db.d.ts",
       "import": "./dist/db.js"
+    },
+    "./client": {
+      "types": "./dist/client/hooks.d.ts",
+      "import": "./dist/client/hooks.js"
     }
   },
   "devDependencies": {

package/scripts/generate.js

@@ -271,6 +271,13 @@ function bundleClientFilesSync(clientFiles, srcDir) {
   return scripts;
 }
 
+function stripRouteGroupSegments(filePath) {
+  return filePath
+    .split("/")
+    .filter((segment) => !/^\(.+\)$/.test(segment))
+    .join("/");
+}
+
 function routePathToDir(filePath) {
   return filePath
     .replace(/\\/g, "/")
@@ -285,6 +292,7 @@ function middlewareImportName(filePath) {
     .replace(/\//g, "_")
     .replace(/\[/g, "$")
     .replace(/\]/g, "")
+    .replace(/[()]/g, "")
     .replace(/-/g, "_")
     .replace(/_+$/, "");
   return `mw_${base || "root"}`;
@@ -307,6 +315,7 @@ function layoutPathToDir(filePath) {
 function pageFilePathToUrlPath(filePath) {
   let urlPath = filePath.replace(/\.tsx?$/, "");
   urlPath = urlPath.replace(/\\/g, "/");
+  urlPath = stripRouteGroupSegments(urlPath);
   urlPath = urlPath.replace(/\[([^\]]+)\]/g, ":$1");
   urlPath = urlPath.replace(/\/page$/, "");
   if (urlPath === "page") urlPath = "";
@@ -322,6 +331,7 @@ function pageFilePathToImportName(filePath) {
       .replace(/\//g, "_")
       .replace(/\[/g, "$")
       .replace(/\]/g, "")
+      .replace(/[()]/g, "")
       .replace(/-/g, "_")
   );
 }
@@ -333,6 +343,7 @@ function layoutImportName(filePath) {
     .replace(/\//g, "_")
     .replace(/\[/g, "$")
     .replace(/\]/g, "")
+    .replace(/[()]/g, "")
     .replace(/-/g, "_")
     .replace(/_+$/, "");
   return `layout_${base || "root"}`;
@@ -402,6 +413,63 @@ function validateNoPageRouteColocation(routeFiles, pageFiles) {
     }
   }
 
+  const routeUrlMap = new Map();
+  for (const f of routeFiles) {
+    routeUrlMap.set(filePathToUrlPath(f), f);
+  }
+  for (const pageFile of pageFiles) {
+    const url = pageFilePathToUrlPath(pageFile);
+    const conflicting = routeUrlMap.get(url);
+    if (conflicting) {
+      const pageDir = pageFilePathToDir(pageFile);
+      if (!routeDirs.has(pageDir)) {
+        errors.push(
+          `[Rain] Error: page "${pageFile}" and route "${conflicting}" resolve to the same URL path "${url}":\n` +
+            "  → This conflict occurs because route group folders are stripped from URLs.\n" +
+            "  → Move one of them to a different URL path.",
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
+function validateNoDuplicateUrls(routeFiles, pageFiles) {
+  const errors = [];
+
+  const routeUrlMap = new Map();
+  for (const f of routeFiles) {
+    const url = filePathToUrlPath(f);
+    if (routeUrlMap.has(url)) {
+      errors.push(
+        `[Rain] Error: multiple route files resolve to the same URL path "${url}":\n` +
+          `  → ${routeUrlMap.get(url)}\n` +
+          `  → ${f}\n` +
+          "  → Route group folders are stripped from URLs.\n" +
+          "  → Rename one of the routes to avoid the conflict.",
+      );
+    } else {
+      routeUrlMap.set(url, f);
+    }
+  }
+
+  const pageUrlMap = new Map();
+  for (const f of pageFiles) {
+    const url = pageFilePathToUrlPath(f);
+    if (pageUrlMap.has(url)) {
+      errors.push(
+        `[Rain] Error: multiple page files resolve to the same URL path "${url}":\n` +
+          `  → ${pageUrlMap.get(url)}\n` +
+          `  → ${f}\n` +
+          "  → Route group folders are stripped from URLs.\n" +
+          "  → Rename one of the pages to avoid the conflict.",
+      );
+    } else {
+      pageUrlMap.set(url, f);
+    }
+  }
+
   return errors;
 }
 
@@ -429,6 +497,7 @@ function getMiddlewaresForRoute(routeFile, middlewareFiles) {
 function filePathToUrlPath(filePath) {
   let urlPath = filePath.replace(/\.tsx?$/, "");
   urlPath = urlPath.replace(/\\/g, "/");
+  urlPath = stripRouteGroupSegments(urlPath);
   urlPath = urlPath.replace(/\[([^\]]+)\]/g, ":$1");
   urlPath = urlPath.replace(/\/route$/, "");
   if (urlPath === "route") urlPath = "";
@@ -444,6 +513,7 @@ function filePathToImportName(filePath) {
       .replace(/\//g, "_")
       .replace(/\[/g, "$")
       .replace(/\]/g, "")
+      .replace(/[()]/g, "")
       .replace(/-/g, "_")
   );
 }
@@ -517,6 +587,65 @@ function detectExportedMethods(filePath) {
   return detectExportedMethodsFromContent(content);
 }
 
+function collectAllExportedNames(node) {
+  if (ts.isVariableStatement(node)) {
+    return node.declarationList.declarations
+      .filter((d) => ts.isIdentifier(d.name))
+      .map((d) => d.name.text);
+  }
+  if (
+    (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+    node.name
+  ) {
+    return [node.name.text];
+  }
+  return [];
+}
+
+function collectAllNamedExports(node) {
+  if (
+    !(
+      ts.isExportDeclaration(node) &&
+      node.exportClause &&
+      ts.isNamedExports(node.exportClause)
+    )
+  ) {
+    return [];
+  }
+  return node.exportClause.elements.map((el) => el.name.text);
+}
+
+function detectAllExportsFromContent(content) {
+  const sourceFile = ts.createSourceFile(
+    "file.tsx",
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  const named = [];
+  let hasDefault = false;
+
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isExportAssignment(node) && !node.isExportEquals) {
+      hasDefault = true;
+      return;
+    }
+    if (hasExportKeyword(node)) {
+      const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
+      if (modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+        hasDefault = true;
+      } else {
+        named.push(...collectAllExportedNames(node));
+      }
+    }
+    named.push(...collectAllNamedExports(node));
+  });
+
+  return { named, hasDefault };
+}
+
 function detectMiddlewareExportFromContent(content) {
   return detectExportedNamesFromContent(content, ["onRequest"]).length > 0;
 }
@@ -703,6 +832,156 @@ function regenerateClient() {
   console.log(`[gen:client] ${clientMsg} -> .rainjs/entry.ts`);
 }
 
+function clientFileToIslandId(relPath) {
+  return relPath
+    .replace(/\\/g, "/")
+    .replace(/\.tsx?$/, "")
+    .replace(/[^a-zA-Z0-9_/]/g, "_");
+}
+
+function generateIslandProxy(clientRelPath, srcDir, fwImport) {
+  const islandDir = path.join(PROJECT_ROOT, BUILD_CONFIG.outDir, "islands");
+  if (!fs.existsSync(islandDir)) {
+    fs.mkdirSync(islandDir, { recursive: true });
+  }
+
+  const fullPath = path.join(srcDir, clientRelPath);
+  const content = fs.readFileSync(fullPath, "utf-8");
+  const { named, hasDefault } = detectAllExportsFromContent(content);
+  const islandId = clientFileToIslandId(clientRelPath);
+
+  const proxyFile = path.join(
+    islandDir,
+    clientRelPath.replace(/\\/g, "/").replace(/\.tsx?$/, ".ts"),
+  );
+  const proxyDir = path.dirname(proxyFile);
+  if (!fs.existsSync(proxyDir)) {
+    fs.mkdirSync(proxyDir, { recursive: true });
+  }
+
+  const proxyEntryDir = path.dirname(proxyFile);
+  let relOriginal = path
+    .relative(
+      proxyEntryDir,
+      path.join(srcDir, clientRelPath.replace(/\.tsx?$/, "")),
+    )
+    .replace(/\\/g, "/");
+  if (!relOriginal.startsWith(".")) relOriginal = `./${relOriginal}`;
+
+  const lines = [];
+  lines.push(`import { markAsIsland } from "${fwImport}";`);
+
+  const importSpecifiers = [];
+  if (hasDefault) {
+    importSpecifiers.push("default as _default");
+  }
+  for (const name of named) {
+    importSpecifiers.push(`${name} as _${name}`);
+  }
+  if (importSpecifiers.length > 0) {
+    lines.push(
+      `import { ${importSpecifiers.join(", ")} } from "${relOriginal}";`,
+    );
+  }
+  lines.push("");
+
+  if (hasDefault) {
+    lines.push(`export default markAsIsland("${islandId}:default", _default);`);
+  }
+  for (const name of named) {
+    lines.push(
+      `export const ${name} = markAsIsland("${islandId}:${name}", _${name});`,
+    );
+  }
+  lines.push("");
+
+  fs.writeFileSync(proxyFile, lines.join("\n"));
+  return { proxyFile, islandId, named, hasDefault };
+}
+
+function generateAllIslandProxies(clientFiles, srcDir, fwImport) {
+  const islandDir = path.join(PROJECT_ROOT, BUILD_CONFIG.outDir, "islands");
+  if (fs.existsSync(islandDir)) {
+    fs.rmSync(islandDir, { recursive: true, force: true });
+  }
+
+  const proxies = [];
+  for (const cf of clientFiles) {
+    proxies.push(generateIslandProxy(cf, srcDir, fwImport));
+  }
+  return proxies;
+}
+
+function updateWranglerAliases(clientFiles, srcDir) {
+  const wranglerPath = path.join(PROJECT_ROOT, "wrangler.toml");
+  if (!fs.existsSync(wranglerPath)) return;
+
+  let content = fs.readFileSync(wranglerPath, "utf-8");
+
+  const markerStart = "# [rain:alias:start]";
+  const markerEnd = "# [rain:alias:end]";
+
+  const startIdx = content.indexOf(markerStart);
+  const endIdx = content.indexOf(markerEnd);
+  if (startIdx !== -1 && endIdx !== -1) {
+    content =
+      content.slice(0, startIdx).trimEnd() +
+      "\n" +
+      content.slice(endIdx + markerEnd.length).trimStart();
+  }
+
+  if (clientFiles.length === 0) {
+    const cleaned = `${content.trimEnd()}
+`;
+    if (cleaned !== fs.readFileSync(wranglerPath, "utf-8")) {
+      fs.writeFileSync(wranglerPath, cleaned);
+    }
+    return;
+  }
+
+  const islandDir = path.join(PROJECT_ROOT, BUILD_CONFIG.outDir, "islands");
+
+  const aliasLines = [markerStart];
+  const hasExistingAlias = /^\[alias\]/m.test(content);
+  if (!hasExistingAlias) {
+    aliasLines.push("[alias]");
+  }
+
+  for (const cf of clientFiles) {
+    const originalAbs = path.join(srcDir, cf.replace(/\.tsx?$/, ""));
+    const proxyAbs = path.join(
+      islandDir,
+      cf.replace(/\\/g, "/").replace(/\.tsx?$/, ".ts"),
+    );
+    const relProxy = path.relative(PROJECT_ROOT, proxyAbs).replace(/\\/g, "/");
+    const relOriginal = path
+      .relative(PROJECT_ROOT, originalAbs)
+      .replace(/\\/g, "/");
+    aliasLines.push(`"./${relOriginal}" = "./${relProxy}"`);
+  }
+  aliasLines.push(markerEnd);
+
+  const aliasBlock = aliasLines.join("\n");
+
+  if (hasExistingAlias) {
+    const aliasIdx = content.search(/^\[alias\]/m);
+    let insertAt = content.indexOf("\n", aliasIdx);
+    if (insertAt === -1) insertAt = content.length;
+    content =
+      content.slice(0, insertAt + 1) +
+      aliasLines.filter((l) => l !== "[alias]").join("\n") +
+      "\n" +
+      content.slice(insertAt + 1);
+  } else {
+    content = `${content.trimEnd()}
+
+${aliasBlock}
+`;
+  }
+
+  fs.writeFileSync(wranglerPath, content);
+}
+
 function generate() {
   if (!fs.existsSync(ROUTES_DIR)) {
     console.error(
@@ -750,6 +1029,12 @@ function generate() {
     process.exit(1);
   }
 
+  const duplicateErrors = validateNoDuplicateUrls(files, pageFiles);
+  for (const err of duplicateErrors) {
+    console.error(err);
+    process.exit(1);
+  }
+
   const hasRootLayout = layoutFiles.some((f) => layoutPathToDir(f) === "");
 
   processMiddlewares(middlewareFiles, imports);
@@ -775,6 +1060,9 @@ function generate() {
       ? relativeImportPath(path.join(PROJECT_ROOT, fwPkg))
       : fwPkg;
 
+  generateAllIslandProxies(clientFiles, srcDir, frameworkImport);
+  updateWranglerAliases(clientFiles, srcDir);
+
   const headerImports = [`import { Rain } from "${frameworkImport}";`];
   if (hasConfig) {
     const configPath = relativeImportPath(
@@ -830,8 +1118,15 @@ module.exports = {
   detectDefaultExport,
   detectDefaultExportFromContent,
   detectUseClientDirective,
+  detectAllExportsFromContent,
+  generateIslandProxy,
+  generateAllIslandProxies,
+  updateWranglerAliases,
+  clientFileToIslandId,
   bundleClientFilesSync,
   validateNoPageRouteColocation,
+  validateNoDuplicateUrls,
+  stripRouteGroupSegments,
   ROUTES_DIR,
   ENTRY_FILE,
   HTTP_METHODS,