@noego/forge 0.0.27 → 0.1.0

package/bin/forge.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { glob } from 'fs/promises';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  console.log('Usage: forge <pattern|files...>');
+  console.log('');
+  console.log('Runs TypeScript files with Svelte support.');
+  console.log('');
+  console.log('Examples:');
+  console.log('  forge test/ui/auth.test.ts');
+  console.log('  forge test/ui/*.test.ts');
+  console.log('  forge "test/ui/**/*.test.ts"');
+  process.exit(0);
+}
+
+async function runFile(file) {
+  return new Promise((resolve) => {
+    const child = spawn(
+      'npx',
+      ['tsx', '--loader', '@noego/forge/loader', file],
+      {
+        stdio: 'inherit',
+        shell: true,
+      }
+    );
+
+    child.on('close', (code) => {
+      resolve({ file, code: code ?? 0 });
+    });
+
+    child.on('error', (err) => {
+      console.error(`Error running ${file}:`, err.message);
+      resolve({ file, code: 1 });
+    });
+  });
+}
+
+async function main() {
+  const files = [];
+
+  // Support both shell expansion (multiple args) and glob patterns
+  for (const arg of args) {
+    if (arg.includes('*')) {
+      // Glob pattern - expand it
+      for await (const file of glob(arg)) {
+        files.push(file);
+      }
+    } else {
+      // Direct file path
+      files.push(arg);
+    }
+  }
+
+  if (files.length === 0) {
+    console.error(`No files found matching: ${args.join(' ')}`);
+    process.exit(1);
+  }
+
+  // Sort for consistent ordering
+  files.sort();
+
+  const results = [];
+
+  for (const file of files) {
+    if (files.length > 1) {
+      console.log(`\n━━━ ${file} ━━━\n`);
+    }
+    const result = await runFile(file);
+    results.push(result);
+  }
+
+  // Summary if multiple files
+  if (files.length > 1) {
+    const passed = results.filter(r => r.code === 0);
+    const failed = results.filter(r => r.code !== 0);
+
+    console.log('\n━━━ Summary ━━━\n');
+    console.log(`Passed: ${passed.length}/${results.length}`);
+
+    if (failed.length > 0) {
+      console.log('\nFailed:');
+      failed.forEach(r => console.log(`  - ${r.file}`));
+    }
+
+    process.exit(failed.length > 0 ? 1 : 0);
+  } else {
+    process.exit(results[0].code);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});

package/dist-ssr/server.cjs

@@ -26,121 +26,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const express = require("express");
 const path = require("path");
-const fs = require("fs");
+const fs$1 = require("fs");
 const deepmerge = require("deepmerge");
-const url = require("url");
+const url_parser = require("./url_parser-CsBTlLeJ.cjs");
 const Handlebars = require("handlebars");
-const fs$1 = require("fs/promises");
+const fs = require("fs/promises");
 const devalue = require("devalue");
-const yaml = require("js-yaml");
-require("clone-deep");
-const join = require("url-join");
-const path$1 = require("./path-sxXxpB6R.cjs");
+const url = require("url");
 const server = require("svelte/server");
-const pathToRegex = require("path-to-regex");
-class ViteComponentLoader {
-  constructor(basePath, vite) {
-    this.basePath = basePath;
-    this.vite = vite;
-  }
-  async load(componentPath, options = { use_base_path: true }) {
-    const absoluteComponentPath = this.getComponentFullPath(componentPath, options);
-    console.log(`[ViteComponentLoader] Loading component from path: ${absoluteComponentPath}`);
-    const jsPath = absoluteComponentPath.replace(/\.svelte$/, ".js");
-    fs.existsSync(jsPath);
-    let vitePath = path.relative(process.cwd(), absoluteComponentPath);
-    vitePath = vitePath.replace(/\\/g, "/");
-    if (!vitePath.startsWith("/")) {
-      vitePath = "/" + vitePath;
-    }
-    console.log(`[ViteComponentLoader] Resolved Vite path: ${vitePath} from componentPath: ${componentPath}`);
-    try {
-      console.log(`[ViteComponentLoader] Loading module for vitePath: ${vitePath}`);
-      const module2 = await this.vite.ssrLoadModule(vitePath);
-      console.log(`[ViteComponentLoader] Module loaded successfully for: ${vitePath}`);
-      if (!module2 || !module2.default) {
-        console.error(`[ViteComponentLoader] Loaded module for ${vitePath} is invalid or missing a default export. Module content:`, module2);
-        throw new Error(`Module ${vitePath} loaded successfully but is invalid or missing default export.`);
-      }
-      return module2;
-    } catch (error) {
-      console.error(`[ViteComponentLoader] Error loading module for vitePath: ${vitePath} (derived from componentPath: ${componentPath})`, error);
-      try {
-        await fs.promises.access(absoluteComponentPath);
-      } catch (fsError) {
-      }
-      throw error;
-    }
-  }
-  getComponentFullPath(componentPath, options = { use_base_path: true }) {
-    const use_base_path = options.use_base_path || false;
-    if (use_base_path) {
-      return path.join(this.basePath, componentPath);
-    }
-    if (path.isAbsolute(componentPath)) {
-      return componentPath;
-    }
-    return componentPath;
-  }
-}
-class ProdComponentLoader {
-  constructor(base_path) {
-    __publicField(this, "componentMapPromise", null);
-    this.base_path = base_path;
-  }
-  async load(componentPath) {
-    const normalized = this.normalizeKey(componentPath);
-    try {
-      const map = await this.loadComponentMap();
-      const module22 = map[normalized];
-      if (module22) {
-        return module22;
-      }
-    } catch (error) {
-      console.warn(`[Forge] Failed to load component "${componentPath}" from entry manifest:`, error);
-    }
-    const component_path = this.getComponentFullPath(componentPath);
-    const fallbackPath = component_path.endsWith(".js") ? component_path : component_path.replace(/\.svelte$/, ".js");
-    const module2 = await import(url.pathToFileURL(fallbackPath).href);
-    return module2;
-  }
-  getComponentFullPath(componentPath) {
-    return path.join(this.base_path, componentPath);
-  }
-  normalizeKey(componentPath) {
-    const trimmed = componentPath.replace(/^\.\//, "");
-    if (trimmed.endsWith(".svelte")) {
-      return trimmed.replace(/\.svelte$/, ".js");
-    }
-    return trimmed;
-  }
-  async loadComponentMap() {
-    if (!this.componentMapPromise) {
-      const entryPath = path.join(this.base_path, "entry-ssr.js");
-      const entryUrl = url.pathToFileURL(entryPath).href;
-      this.componentMapPromise = import(entryUrl).then((mod) => {
-        const source = mod.components ?? mod.default ?? {};
-        const normalized = {};
-        for (const [key, value] of Object.entries(source)) {
-          const cleanKey = key.replace(/^\.\//, "");
-          normalized[cleanKey] = value;
-          if (cleanKey.startsWith("ui/")) {
-            normalized[cleanKey.slice(3)] = value;
-          }
-          if (cleanKey.endsWith(".svelte")) {
-            const jsKey = cleanKey.replace(/\.svelte$/, ".js");
-            normalized[jsKey] = value;
-          }
-        }
-        return normalized;
-      }).catch((error) => {
-        this.componentMapPromise = null;
-        throw error;
-      });
-    }
-    return this.componentMapPromise;
-  }
-}
 const default_template = `
 <!DOCTYPE html>
 <html lang="en">
@@ -279,146 +172,10 @@ if (document.readyState === 'loading') {
     return html;
   }
   async getTemplate() {
-    const file_content = await fs$1.readFile(this.html_path, "utf8");
+    const file_content = await fs.readFile(this.html_path, "utf8");
     return file_content;
   }
 }
-const HTTP_METHODS = /* @__PURE__ */ new Set([
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options",
-  "trace"
-]);
-function getGlobalPathsMiddleware(openapi) {
-  if (!openapi || !openapi.paths) {
-    return [];
-  }
-  const value = openapi.paths["x-middleware"];
-  return Array.isArray(value) ? [...value] : [];
-}
-function parseConfigfile(file_content) {
-  let config = null;
-  try {
-    config = yaml.load(file_content);
-  } catch (e) {
-    console.log(e);
-  }
-  return config;
-}
-function parse_modules(openapi, inheritedMiddleware = []) {
-  const modules_config = openapi.modules || openapi.module;
-  if (!modules_config) {
-    return;
-  }
-  const modules = Object.entries(modules_config).map(([_, module2]) => {
-    return module2;
-  });
-  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
-  const modules_path = modules.map((module2) => {
-    const basePath = module2.basePath || "";
-    const baseLayouts = module2.baseLayouts || [];
-    const moduleMiddleware = Array.isArray(module2["x-middleware"]) ? module2["x-middleware"] : [];
-    const inherited = [...globalMiddleware, ...moduleMiddleware];
-    const paths = module2.paths;
-    if (!paths) {
-      return;
-    }
-    const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
-      return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
-        const methodName = String(method);
-        return path$1.parsePathConfig(path2, methodName, config, inherited);
-      });
-    });
-    const routes = configurations.reduce((flat_config, config) => {
-      return flat_config.concat(config);
-    }, []);
-    routes.forEach((route) => {
-      route.path = join(basePath, route.path);
-      route.layout = baseLayouts.concat(route.layout || []);
-    });
-    return routes;
-  });
-  return modules_path.reduce(
-    (flat_config, config) => {
-      if (!config) {
-        return flat_config;
-      }
-      return flat_config.concat(config);
-    },
-    []
-  );
-}
-function parse_paths(openapi, inheritedMiddleware = []) {
-  const paths = openapi.paths;
-  if (!paths) {
-    return;
-  }
-  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
-  const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
-    return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
-      const methodName = String(method);
-      return path$1.parsePathConfig(path2, methodName, config, globalMiddleware);
-    });
-  });
-  const routes = configurations.reduce((flat_config, config) => {
-    return flat_config.concat(config);
-  }, []);
-  return routes;
-}
-function isStitchConfig(document) {
-  return document && typeof document === "object" && "stitch" in document;
-}
-function isOpenAPIConfig(document) {
-  return document && typeof document === "object" && ("paths" in document || "module" in document || "modules" in document);
-}
-async function parse_openapi_config(openapi_config_path) {
-  const content = fs.readFileSync(openapi_config_path, "utf8");
-  const parsed_config = parseConfigfile(content);
-  let openapi_config;
-  if (isStitchConfig(parsed_config)) {
-    console.log("Detected stitch configuration, building with Node.js stitch engine...");
-    try {
-      const { StitchEngine } = await import("@noego/stitch");
-      const startTime = Date.now();
-      const engine = new StitchEngine();
-      const result = engine.buildSync(openapi_config_path, { format: "json" });
-      if (!result.success) {
-        throw new Error(`Stitch build failed: ${result.error}`);
-      }
-      const buildTime = Date.now() - startTime;
-      console.log(`INFO  Stitch build completed in ${buildTime} ms – ${parsed_config.stitch ? parsed_config.stitch.length : 0} modules processed`);
-      openapi_config = typeof result.data === "string" ? JSON.parse(result.data) : result.data;
-    } catch (error) {
-      throw new Error(`Failed to process stitch configuration: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  } else if (isOpenAPIConfig(parsed_config)) {
-    console.log("Detected regular OpenAPI configuration");
-    openapi_config = parsed_config;
-  } else {
-    throw new Error(`Invalid OpenAPI or stitch configuration file: ${openapi_config_path}. File must contain either 'stitch', 'paths', 'module', or 'modules' at the root level.`);
-  }
-  const globalPathsMiddleware = getGlobalPathsMiddleware(openapi_config);
-  let modules = parse_modules(openapi_config) || [];
-  let paths = parse_paths(openapi_config) || [];
-  let fallback_layout = openapi_config["x-fallback-layout"] || null;
-  let fallback_view = openapi_config["x-fallback-view"] || null;
-  const fallback_middleware = Array.isArray(openapi_config["x-fallback-middleware"]) ? [...openapi_config["x-fallback-middleware"]] : [...globalPathsMiddleware];
-  let fallback = {
-    layout: fallback_layout ? [fallback_layout] : [],
-    view: fallback_view,
-    middleware: fallback_middleware
-  };
-  const routes = [...modules, ...paths];
-  let config = {
-    fallback,
-    routes
-  };
-  return config;
-}
 const defaultViteOptions = {
   appType: "custom",
   root: process.cwd(),
@@ -446,7 +203,7 @@ class ManifestBuilder {
     this.full_options = deepmerge(defaultOptions, this.options);
   }
   async buildManifest() {
-    const configuration = await parse_openapi_config(this.openapi_path);
+    const configuration = await url_parser.parse_openapi_config(this.openapi_path);
     const component_path = this.full_options.component_dir;
     if (!component_path) {
       throw new Error("Component path is not defined");
@@ -487,7 +244,7 @@ async function layout_requires_server(route, loader) {
     for (const ext of extensions) {
       const loaderFilePath = path.join(dir, `${name}.load${ext}`);
       try {
-        if (fs.existsSync(loaderFilePath)) {
+        if (fs$1.existsSync(loaderFilePath)) {
           const module2 = await import(url.pathToFileURL(loaderFilePath).href);
           if (typeof (module2 == null ? void 0 : module2.default) === "function") {
             return true;
@@ -516,7 +273,7 @@ async function view_requires_server(route, loader) {
   for (const ext of extensions) {
     const loaderFilePath = path.join(dir, `${name}.load${ext}`);
     try {
-      if (fs.existsSync(loaderFilePath)) {
+      if (fs$1.existsSync(loaderFilePath)) {
         const module2 = await import(url.pathToFileURL(loaderFilePath).href);
         if (typeof (module2 == null ? void 0 : module2.default) === "function") {
           return true;
@@ -628,106 +385,6 @@ class ApiAdapter {
     };
   }
 }
-class ComponentManager {
-  constructor(componentLoader) {
-    this.componentLoader = componentLoader;
-  }
-  async getLayoutComponents(route) {
-    const layout_paths = route.layout || [];
-    const layouts_components = await Promise.all(layout_paths.map((layout) => {
-      console.log("layout path", layout);
-      return this.componentLoader.load(layout);
-    }));
-    return layouts_components;
-  }
-  async getLayouts(route) {
-    const layout_paths = route.layout || [];
-    const layouts_components = await Promise.all(layout_paths.map(async (layout_path) => {
-      const layout = await this.componentLoader.load(layout_path);
-      return layout.default;
-    }));
-    return layouts_components;
-  }
-  async getLayoutLoaders(route) {
-    const layout_paths = route.layout || [];
-    const loaders_from_files = await Promise.all(
-      layout_paths.map((layoutPath) => this.resolveLoader(layoutPath))
-    );
-    const needs_fallback = loaders_from_files.some((loader) => !loader);
-    if (needs_fallback) {
-      const layout_components = await this.getLayoutComponents(route);
-      const old_style_loaders = layout_components.map((layout) => layout.load);
-      return loaders_from_files.map(
-        (loader, index) => loader || old_style_loaders[index] || null
-      );
-    }
-    return loaders_from_files;
-  }
-  async getViewComponent(route) {
-    return await this.componentLoader.load(route.view);
-  }
-  async hasLoaders(route) {
-    const componentPaths = [...route.layout || [], route.view];
-    for (const componentPath of componentPaths) {
-      const loader = await this.resolveLoader(componentPath);
-      if (loader) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async getLoaders(route) {
-    const layoutPaths = route.layout || [];
-    const layouts = await Promise.all(layoutPaths.map((layoutPath) => this.resolveLoader(layoutPath)));
-    const view = await this.resolveLoader(route.view);
-    return {
-      layouts,
-      view
-    };
-  }
-  getLoaderFilePath(componentPath, extension = ".js") {
-    if (!componentPath) {
-      return null;
-    }
-    const fullPath = this.componentLoader.getComponentFullPath(componentPath);
-    const { dir, name } = path.parse(fullPath);
-    return path.join(dir, `${name}.load${extension}`);
-  }
-  async resolveLoader(componentPath) {
-    if (!componentPath) {
-      return null;
-    }
-    const extensions = [".js", ".ts"];
-    for (const ext of extensions) {
-      const loaderFilePath = this.getLoaderFilePath(componentPath, ext);
-      if (!loaderFilePath) {
-        continue;
-      }
-      try {
-        console.log(`[ComponentManager] Trying loader path: ${loaderFilePath}`);
-        const module2 = await import(url.pathToFileURL(loaderFilePath).href);
-        const loader = module2 == null ? void 0 : module2.default;
-        console.log(`[ComponentManager] Imported loader module: default=${typeof loader}`);
-        if (typeof loader === "function") {
-          console.log(`[ComponentManager] Loaded loader function from: ${loaderFilePath}`);
-          return loader;
-        }
-      } catch (error) {
-        const code = (error == null ? void 0 : error.code) || (error == null ? void 0 : error.name) || "UNKNOWN_ERROR";
-        if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-          console.warn(`[ComponentManager] Loader not found at ${loaderFilePath} (${ext}): ${(error == null ? void 0 : error.message) || code}`);
-          continue;
-        }
-        console.error(`[ComponentManager] Failed to load loader for ${componentPath} (${ext}) at ${loaderFilePath}:`, error);
-      }
-    }
-    return null;
-  }
-  async getView(route) {
-    const view = await this.componentLoader.load(route.view);
-    return view.default;
-  }
-}
 const EXTENSION_CANDIDATES = [".js", ".mjs", ".cjs", ".ts", ".tsx"];
 class MiddlewareAdapter {
   constructor(middlewarePath, fallbackPath) {
@@ -806,17 +463,17 @@ class MiddlewareAdapter {
   findExistingFile(basePathWithoutExt) {
     const ext = path.extname(basePathWithoutExt);
     if (ext) {
-      return fs.existsSync(basePathWithoutExt) ? basePathWithoutExt : null;
+      return fs$1.existsSync(basePathWithoutExt) ? basePathWithoutExt : null;
     }
     const directCandidates = EXTENSION_CANDIDATES.map((extCandidate) => `${basePathWithoutExt}${extCandidate}`);
     for (const candidate of directCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs$1.existsSync(candidate)) {
         return candidate;
       }
     }
     const indexCandidates = EXTENSION_CANDIDATES.map((extCandidate) => path.join(basePathWithoutExt, `index${extCandidate}`));
     for (const candidate of indexCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs$1.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -910,20 +567,6 @@ class MiddlewareAdapter {
     return ordered;
   }
 }
-function makeUrlParser(pattern) {
-  const parser = new pathToRegex(pattern);
-  return (pathname) => {
-    const result = parser.match(pathname);
-    return result || null;
-  };
-}
-function initialize_route_matchers(routes) {
-  return routes.map((route) => {
-    const pattern = route.path;
-    const parser = makeUrlParser(pattern);
-    return { pattern, parser };
-  });
-}
 class ServerAdapter {
 }
 class ExpressServerAdapter extends ServerAdapter {
@@ -985,7 +628,7 @@ class ExpressServerAdapter extends ServerAdapter {
   async handleRoutes(routes, manifest) {
     const transformedRoutes = this.transformRoutesForClient(routes);
     this.clientRoutes = transformedRoutes;
-    const matchers = initialize_route_matchers(transformedRoutes);
+    const matchers = url_parser.initialize_route_matchers(transformedRoutes);
     this.server.use((req, res, next) => {
       (async () => {
         if (res.headersSent) {
@@ -1252,7 +895,7 @@ view: ${route.view}</pre>`;
 }
 function pathExistsSync(p) {
   try {
-    return fs.existsSync(p);
+    return fs$1.existsSync(p);
   } catch {
     return false;
   }
@@ -1319,7 +962,7 @@ async function createServer(app, options) {
     vite = await createViteServer(options.viteOptions || full_options.viteOptions);
     console.log(`Vite server created options 
 ${JSON.stringify(options, null, 2)}`);
-    componentLoader = new ViteComponentLoader(COMPONENT_DIR, vite);
+    componentLoader = new url_parser.ViteComponentLoader(COMPONENT_DIR, vite);
   } else {
     console.log("Starting Vite in production mode...");
     const staticDir = path.join(full_options.viteOptions.root, full_options.build_dir);
@@ -1332,7 +975,7 @@ ${JSON.stringify(options, null, 2)}`);
     const componentPath = `/${full_options.component_dir}`;
     app.use(componentPath, express.static(COMPONENT_DIR));
     console.log(`Serving components at ${componentPath} from ${COMPONENT_DIR}`);
-    componentLoader = new ProdComponentLoader(COMPONENT_DIR);
+    componentLoader = new url_parser.ProdComponentLoader(COMPONENT_DIR);
   }
   const manifest = await new ManifestBuilder(
     full_options.open_api_path,
@@ -1340,9 +983,9 @@ ${JSON.stringify(options, null, 2)}`);
     full_options
   ).buildManifest();
   const htmlRenderer = getRenderer(root, full_options.renderer, isProd);
-  const server_config = await parse_openapi_config(full_options.open_api_path);
+  const server_config = await url_parser.parse_openapi_config(full_options.open_api_path);
   const routeDefs = server_config.routes;
-  const manager = new ComponentManager(componentLoader);
+  const manager = new url_parser.ComponentManager(componentLoader);
   const api_adapter = new ApiAdapter(manager);
   let middlewareRoot;
   if (full_options.middleware_path) {
@@ -1374,7 +1017,7 @@ function getRenderer(root, renderer, isProd) {
     return new LiveHTMLRender(ensureFullPath(root, renderer));
   } else if (typeof renderer === "string" && isProd) {
     const html = ensureFullPath(root, renderer);
-    const template = fs.readFileSync(html, "utf8");
+    const template = fs$1.readFileSync(html, "utf8");
     return new BaseHTMLRender(template);
   } else if (renderer instanceof BaseHTMLRender) {
     return renderer;