nvent 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/module.d.mts

@@ -338,6 +338,55 @@ interface NventIiiOptions {
     };
 }
 
+interface LayerInfo {
+    rootDir: string;
+    serverDir: string;
+    /**
+     * Prefix prepended to every function ID discovered in this layer.
+     * Empty string (or undefined) means no prefix — root project convention.
+     * e.g. 'auth' → 'login.ts' becomes 'auth::login'
+     */
+    prefix?: string;
+}
+
+interface NventExtendedFunction {
+    /** iii function ID (e.g. `fhir::terminology::lookup`) */
+    id: string;
+    /** Absolute file path, or root-relative path, to a TS/JS function module */
+    absPath: string;
+    /** Optional human-readable description */
+    description?: string;
+}
+interface NventExtendedPythonFunction {
+    /** iii function ID (e.g. `fhir::terminology::expand`) */
+    id: string;
+    /** Absolute file path, or root-relative path, to a .py file */
+    absPath: string;
+    /** When true, start this function in a dedicated worker process */
+    standalone?: boolean;
+}
+interface NventExtendFunctionsHookPayload {
+    /** Push extra TS/JS function files to register */
+    functions: NventExtendedFunction[];
+    /** Push extra Python function files to register */
+    pythonFunctions: NventExtendedPythonFunction[];
+    /** Nuxt project root */
+    rootDir: string;
+    /** Layer scan context (same as nvent internal scan) */
+    layerInfos: LayerInfo[];
+    /** Configured functions dir relative to each layer's server dir */
+    functionsDir: string;
+}
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        /**
+         * Extend nvent function discovery with additional TS/JS or Python function files.
+         * Useful for Nuxt modules that ship their own iii handlers.
+         */
+        'nvent:functions:extend': (payload: NventExtendFunctionsHookPayload) => void | Promise<void>;
+    }
+}
 declare const _default: _nuxt_schema.NuxtModule<NventIiiOptions, NventIiiOptions, false>;
 
 export { _default as default };
+export type { NventExtendFunctionsHookPayload, NventExtendedFunction, NventExtendedPythonFunction };

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "configKey": "nvent",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { join, dirname, basename, relative, parse } from 'node:path';
+import { join, dirname, basename, relative, parse, isAbsolute } from 'node:path';
 import { defineNuxtModule, createResolver, extendViteConfig, hasNuxtModule, addTemplate, addServerPlugin, addServerHandler, addServerImports, addImports, addPlugin, updateTemplates } from '@nuxt/kit';
 import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, writeFileSync, readFileSync, copyFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
@@ -1133,6 +1133,26 @@ function mapPubSubAdapter(a) {
   return { name: "local" };
 }
 
+function resolveExtendedFunctionAbsPath(absPath) {
+  if (existsSync(absPath)) {
+    return { absPath };
+  }
+  if (!absPath.endsWith(".ts")) {
+    return { absPath };
+  }
+  const base = absPath.slice(0, -3);
+  for (const ext of [".js", ".mjs", ".cjs"]) {
+    const candidate = `${base}${ext}`;
+    if (existsSync(candidate)) {
+      return {
+        absPath: candidate,
+        rewrittenFrom: absPath
+      };
+    }
+  }
+  return { absPath };
+}
+
 function filePathToFunctionId(relPath) {
   const noExt = relPath.replace(/\.[a-zA-Z]+$/, "");
   return noExt.split(/[\\/]/).join("::");
@@ -1368,7 +1388,56 @@ const module$1 = defineNuxtModule({
       serverDir: l.config?.serverDir ?? join(l.config.rootDir, "server"),
       prefix: resolveLayerPrefix(l, i === 0)
     }));
-    let lastScanned = await scanFunctions({ layerInfos, functionsDir });
+    async function scanFunctionsWithExtensions() {
+      const scanned = await scanFunctions({ layerInfos, functionsDir });
+      const payload = {
+        functions: [],
+        pythonFunctions: [],
+        rootDir: nuxt.options.rootDir,
+        layerInfos,
+        functionsDir
+      };
+      await nuxt.callHook("nvent:functions:extend", payload);
+      const normalizePath = (path) => isAbsolute(path) ? path : join(nuxt.options.rootDir, path);
+      const seenTs = new Set(scanned.functions.map((f) => f.id));
+      for (const fn of payload.functions) {
+        if (!fn?.id || !fn?.absPath) continue;
+        if (seenTs.has(fn.id)) {
+          console.warn(`[nvent] skipping extended TS function '${fn.id}' (duplicate id)`);
+          continue;
+        }
+        const requestedPath = normalizePath(fn.absPath);
+        const resolvedPath = resolveExtendedFunctionAbsPath(requestedPath);
+        if (resolvedPath.rewrittenFrom) {
+          console.warn(`[nvent] extended TS function path rewritten for '${fn.id}': ${resolvedPath.rewrittenFrom} -> ${resolvedPath.absPath}`);
+        }
+        scanned.functions.push({
+          id: fn.id,
+          absPath: resolvedPath.absPath,
+          relativePath: basename(resolvedPath.absPath),
+          description: fn.description
+        });
+        seenTs.add(fn.id);
+      }
+      const seenPy = new Set(scanned.pythonFunctions.map((f) => f.id));
+      for (const fn of payload.pythonFunctions) {
+        if (!fn?.id || !fn?.absPath) continue;
+        if (seenPy.has(fn.id)) {
+          console.warn(`[nvent] skipping extended Python function '${fn.id}' (duplicate id)`);
+          continue;
+        }
+        const absPath = normalizePath(fn.absPath);
+        scanned.pythonFunctions.push({
+          id: fn.id,
+          absPath,
+          relativePath: basename(absPath),
+          standalone: !!fn.standalone
+        });
+        seenPy.add(fn.id);
+      }
+      return scanned;
+    }
+    let lastScanned = await scanFunctionsWithExtensions();
     let pythonPathRewrite;
     if (!nuxt.options.dev && !skipPython && lastScanned.pythonFunctions.length > 0) {
       pythonPathRewrite = /* @__PURE__ */ new Map();
@@ -1380,6 +1449,10 @@ const module$1 = defineNuxtModule({
             break;
           }
         }
+        if (!pythonPathRewrite.has(fn.absPath)) {
+          const rel = `${fn.id.replace(/::/g, "/")}.py`.replace(/[^a-zA-Z0-9/_\-.]/g, "_");
+          pythonPathRewrite.set(fn.absPath, rel);
+        }
       }
     }
     addTemplate({
@@ -1490,7 +1563,7 @@ const module$1 = defineNuxtModule({
         (l) => join(l.serverDir ?? join(l.rootDir, "server"), functionsDir)
       );
       const refresh = debounce(async (changedPath) => {
-        lastScanned = await scanFunctions({ layerInfos, functionsDir });
+        lastScanned = await scanFunctionsWithExtensions();
         await updateTemplates({ filter: (t) => t.filename === III_REGISTRY_TEMPLATE });
         console.log(`[nvent] registry refreshed${changedPath ? ` (${changedPath})` : ""}`);
         if (!skipPython && changedPath?.endsWith(".py")) {
@@ -1526,15 +1599,18 @@ const module$1 = defineNuxtModule({
           copyFileSync(PYTHON_RUNTIME_SRC, join(workersDir, "_runtime.py"));
           copyFileSync(PYTHON_NVENT_HELPER_SRC, join(workersDir, "nvent.py"));
           for (const fn of lastScanned.pythonFunctions) {
+            let relativeDest;
             for (const layer of layerInfos) {
               const fnDir = join(layer.serverDir, functionsDir);
               if (fn.absPath.startsWith(fnDir)) {
-                const dest = join(outputNventDir, "functions", relative(fnDir, fn.absPath));
-                mkdirSync(join(dest, ".."), { recursive: true });
-                copyFileSync(fn.absPath, dest);
+                relativeDest = relative(fnDir, fn.absPath);
                 break;
               }
             }
+            relativeDest ||= pythonPathRewrite?.get(fn.absPath) ?? `${fn.id.replace(/::/g, "/")}.py`;
+            const dest = join(outputNventDir, "functions", relativeDest);
+            mkdirSync(join(dest, ".."), { recursive: true });
+            copyFileSync(fn.absPath, dest);
           }
           console.log("[nvent] Python worker files copied to .output/nvent/");
         });

package/dist/types.d.mts

@@ -5,3 +5,5 @@ import type { default as Module } from './module.mjs'
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
 export { default } from './module.mjs'
+
+export { type NventExtendFunctionsHookPayload, type NventExtendedFunction, type NventExtendedPythonFunction } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "description": "Event-driven workflows for Nuxt",
   "repository": "nhealthorg/nvent",
   "license": "MIT",