feat(job-service): replace hardcoded function registry with manifest loader

Wave 4b of the portable-functions toolkit. The hardcoded registry at
job/service/src/index.ts:34-43 was the biggest portability blocker —
adding a function required editing this map. Now the registry is
loaded at runtime from one of three sources, in priority order:

  1. FUNCTIONS_REGISTRY env var
     Format: "name:moduleName:port,..." (moduleName + port optional;
     missing moduleName falls back to @constructive-io/<name>-fn).
  2. FUNCTIONS_MANIFEST_PATH env var pointing to a JSON file with the
     existing functions-manifest.json shape. Manifest entries can carry
     an optional moduleName field; otherwise convention applies.
  3. Default: <cwd>/generated/functions-manifest.json (the file the
     toolkit's fn-generator produces).

If no source resolves, the registry is empty; lookups still throw the
legacy "Unknown function X" error to preserve existing behaviour.

Implementation lives in job/service/src/registry.ts (new), exporting
loadFunctionRegistry(env, cwd) for testability. job/service/src/index.ts
imports the loader and replaces the const at the top of the file; the
rest of the file is unchanged.

types.ts: FunctionName widened from a literal union to `string` since
names are dynamic. All existing call sites continue to compile.

Tests: tests/integration/job-registry.test.ts covers the three sources,
override behaviour, and the moduleName convention. All 6 cases pass.
Existing unit (4 suites, 19 tests) and integration (runtime.test.ts, 3
tests) still pass.

Author: Anmol1696

job/service/src/index.ts

@@ -25,22 +25,12 @@ import {
   KnativeJobsSvcResult,
   StartedFunction
 } from './types';
+import {
+  FunctionRegistryEntry,
+  loadFunctionRegistry
+} from './registry';
 
-type FunctionRegistryEntry = {
-  moduleName: string;
-  defaultPort: number;
-};
-
-const functionRegistry: Record<FunctionName, FunctionRegistryEntry> = {
-  'simple-email': {
-    moduleName: '@constructive-io/simple-email-fn',
-    defaultPort: 8081
-  },
-  'send-email-link': {
-    moduleName: '@constructive-io/send-email-link-fn',
-    defaultPort: 8082
-  }
-};
+const functionRegistry = loadFunctionRegistry();
 
 const log = new Logger('knative-job-service');
 const requireFn = createRequire(__filename);

job/service/src/registry.ts

@@ -0,0 +1,84 @@
+/**
+ * Function registry loader for the in-process function server.
+ *
+ * Sources, in priority order:
+ *   1. FUNCTIONS_REGISTRY env var
+ *      Format: "name:moduleName:port,..." (port optional)
+ *      Example: "simple-email:@org/simple-email-fn:8081,foo:@org/foo-fn"
+ *   2. FUNCTIONS_MANIFEST_PATH env var pointing to a JSON file with shape
+ *        { functions: [{ name, dir, port, type, moduleName? }] }
+ *   3. Default file: <cwd>/generated/functions-manifest.json
+ *
+ * If no source resolves, the registry is empty; callers throw on lookup of
+ * an unknown function (preserves the legacy "Unknown function X" behaviour).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface FunctionRegistryEntry {
+  moduleName: string;
+  defaultPort: number;
+}
+
+export type FunctionRegistry = Record<string, FunctionRegistryEntry>;
+
+const DEFAULT_MODULE_PREFIX = '@constructive-io/';
+const DEFAULT_MODULE_SUFFIX = '-fn';
+
+const conventionalModuleName = (name: string): string =>
+  `${DEFAULT_MODULE_PREFIX}${name}${DEFAULT_MODULE_SUFFIX}`;
+
+const parseEnvRegistry = (raw: string): FunctionRegistry => {
+  const out: FunctionRegistry = {};
+  for (const pair of raw.split(',')) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    const [name, moduleName, portStr] = trimmed.split(':').map((s) => s.trim());
+    if (!name) continue;
+    const portNumber = portStr ? Number(portStr) : NaN;
+    out[name] = {
+      moduleName: moduleName || conventionalModuleName(name),
+      defaultPort: Number.isFinite(portNumber) ? portNumber : 0,
+    };
+  }
+  return out;
+};
+
+interface ManifestEntry {
+  name: string;
+  dir?: string;
+  port?: number;
+  type?: string;
+  moduleName?: string;
+}
+
+const fromManifestEntry = (entry: ManifestEntry): FunctionRegistryEntry => ({
+  moduleName: entry.moduleName ?? conventionalModuleName(entry.name),
+  defaultPort: typeof entry.port === 'number' ? entry.port : 0,
+});
+
+const loadManifestFile = (manifestPath: string): FunctionRegistry => {
+  const raw = fs.readFileSync(manifestPath, 'utf-8');
+  const parsed = JSON.parse(raw) as { functions?: ManifestEntry[] };
+  const out: FunctionRegistry = {};
+  for (const entry of parsed.functions ?? []) {
+    if (!entry.name) continue;
+    out[entry.name] = fromManifestEntry(entry);
+  }
+  return out;
+};
+
+export const loadFunctionRegistry = (
+  env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd()
+): FunctionRegistry => {
+  if (env.FUNCTIONS_REGISTRY) {
+    return parseEnvRegistry(env.FUNCTIONS_REGISTRY);
+  }
+  const manifestPath =
+    env.FUNCTIONS_MANIFEST_PATH ?? path.join(cwd, 'generated', 'functions-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    return loadManifestFile(manifestPath);
+  }
+  return {};
+};

job/service/src/types.ts

@@ -1,4 +1,9 @@
-export type FunctionName = 'simple-email' | 'send-email-link';
+/**
+ * Function names are dynamic — looked up at runtime from the registry loaded
+ * from generated/functions-manifest.json (or the FUNCTIONS_MANIFEST_PATH /
+ * FUNCTIONS_REGISTRY env vars). Kept as an alias for narrowing intent.
+ */
+export type FunctionName = string;
 
 export type FunctionServiceConfig = {
   name: FunctionName;

tests/integration/job-registry.test.ts

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { loadFunctionRegistry } from '../../job/service/src/registry';
+
+describe('loadFunctionRegistry', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fn-registry-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns empty when no env vars and no manifest file exist', () => {
+    const reg = loadFunctionRegistry({}, tmpDir);
+    expect(reg).toEqual({});
+  });
+
+  it('reads from generated/functions-manifest.json by default', () => {
+    const dir = path.join(tmpDir, 'generated');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'functions-manifest.json'),
+      JSON.stringify({
+        functions: [
+          { name: 'simple-email', dir: 'simple-email', port: 8081, type: 'node-graphql' },
+          { name: 'send-email-link', dir: 'send-email-link', port: 8082, type: 'node-graphql' },
+        ],
+      })
+    );
+    const reg = loadFunctionRegistry({}, tmpDir);
+    expect(reg['simple-email']).toEqual({
+      moduleName: '@constructive-io/simple-email-fn',
+      defaultPort: 8081,
+    });
+    expect(reg['send-email-link']).toEqual({
+      moduleName: '@constructive-io/send-email-link-fn',
+      defaultPort: 8082,
+    });
+  });
+
+  it('honours FUNCTIONS_MANIFEST_PATH override', () => {
+    const manifestPath = path.join(tmpDir, 'custom-manifest.json');
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify({ functions: [{ name: 'foo', port: 9000 }] })
+    );
+    const reg = loadFunctionRegistry({ FUNCTIONS_MANIFEST_PATH: manifestPath }, tmpDir);
+    expect(reg.foo).toEqual({ moduleName: '@constructive-io/foo-fn', defaultPort: 9000 });
+  });
+
+  it('respects an explicit moduleName field in the manifest', () => {
+    const manifestPath = path.join(tmpDir, 'm.json');
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify({
+        functions: [{ name: 'foo', moduleName: '@my-org/foo-handler', port: 9000 }],
+      })
+    );
+    const reg = loadFunctionRegistry({ FUNCTIONS_MANIFEST_PATH: manifestPath }, tmpDir);
+    expect(reg.foo.moduleName).toBe('@my-org/foo-handler');
+  });
+
+  it('parses FUNCTIONS_REGISTRY env var (priority over manifest)', () => {
+    const manifestPath = path.join(tmpDir, 'm.json');
+    fs.writeFileSync(manifestPath, JSON.stringify({ functions: [{ name: 'foo', port: 1 }] }));
+    const reg = loadFunctionRegistry(
+      {
+        FUNCTIONS_REGISTRY: 'foo:@org/foo:8081,bar:@org/bar',
+        FUNCTIONS_MANIFEST_PATH: manifestPath,
+      },
+      tmpDir
+    );
+    expect(reg.foo).toEqual({ moduleName: '@org/foo', defaultPort: 8081 });
+    // bar has no port → 0
+    expect(reg.bar).toEqual({ moduleName: '@org/bar', defaultPort: 0 });
+  });
+
+  it('uses convention when FUNCTIONS_REGISTRY entry omits moduleName', () => {
+    const reg = loadFunctionRegistry({ FUNCTIONS_REGISTRY: 'baz::8083' }, tmpDir);
+    expect(reg.baz).toEqual({ moduleName: '@constructive-io/baz-fn', defaultPort: 8083 });
+  });
+});