@xemahq/api-client-generator 0.2.0 → 0.3.0

package/src/lib/generate-clients.ts

@@ -0,0 +1,240 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { ALL_SURFACES, type ApiSurface } from '@xemahq/xema-decorators';
+
+import { ensureClientPackage } from './client-package';
+import { ensureClientReadme } from './client-readme';
+import { postProcessClient } from './repo-post-process';
+import {
+  resolveServiceContext,
+  surfaceClientDir,
+  surfaceClientPackageName,
+  surfaceSpecPath,
+  type ResolvedServiceContext,
+} from './service-config';
+
+/**
+ * Native dynamic import of a module resolved from the SERVICE's node_modules
+ * (so we use the service's orval, not the generator's). `new Function` keeps
+ * the `import()` from being downleveled to `require()` by the CJS transpile,
+ * so an ESM-only orval still loads.
+ */
+async function importFromService(
+  serviceDir: string,
+  request: string,
+): Promise<Record<string, unknown>> {
+  const resolved = require.resolve(request, { paths: [serviceDir] });
+  const dynamicImport = new Function('u', 'return import(u)') as (
+    u: string,
+  ) => Promise<Record<string, unknown>>;
+  return dynamicImport(pathToFileURL(resolved).href);
+}
+
+type OrvalGenerate = (config: unknown) => Promise<unknown>;
+
+async function resolveOrvalGenerate(
+  serviceDir: string,
+): Promise<OrvalGenerate> {
+  const mod = await importFromService(serviceDir, 'orval');
+  const generate =
+    (mod.generate as OrvalGenerate | undefined) ??
+    (mod.default as { generate?: OrvalGenerate } | undefined)?.generate;
+  if (typeof generate !== 'function') {
+    throw new Error(
+      'api-client-generator: could not resolve orval `generate` from the service.',
+    );
+  }
+  return generate;
+}
+
+/**
+ * In-memory orval config equivalent to the legacy per-service orval.config.ts.
+ * orval's programmatic `generate()` expects a SINGLE normalized project config
+ * (`{ input, output }`), not the named-project map the CLI reads from a file.
+ */
+function orvalConfigFor(specPath: string, clientSrc: string): unknown {
+  return {
+    input: { target: specPath },
+    output: {
+      mode: 'tags-split',
+      target: `${clientSrc}/endpoints`,
+      schemas: `${clientSrc}/models`,
+      client: 'fetch',
+      override: {
+        fetch: { includeHttpResponseReturnType: false },
+        mutator: {
+          path: `${clientSrc}/custom-fetch.ts`,
+          name: 'customFetch',
+        },
+      },
+    },
+  };
+}
+
+/**
+ * Orphan backlog, keyed `<serviceId>:<surface>` → why it is not fixable from
+ * the generator. **Currently EMPTY, and it must stay that way.**
+ *
+ * It briefly carried five entries: services that capability auto-projection had
+ * reclassified fully-internal without retiring their PUBLIC-surface client
+ * package. All five are resolved — `audit-log-api` regained a genuine Public
+ * surface (two `platform_admin` browser reads); `biome-fetcher-api`,
+ * `policy-distributor-api`, `workspace-git-api` and
+ * `workspace-storage-pool-api` are service-to-service only and their public
+ * client packages were deleted.
+ *
+ * An entry here is a tracked backlog item, never a silent pass — the same
+ * contract as `tooling/boundaries/stack-confidentiality-baseline.json`. Adding
+ * one buys time for a condition the generator genuinely cannot resolve; it is
+ * NOT a place to park a newly-orphaned client. Resolve the orphan instead:
+ * either the service emits the surface (fix the classification at the route,
+ * and give it a real guard) or it does not (delete the package and migrate
+ * consumers to the internal client).
+ */
+const KNOWN_ORPHANED_SURFACE_CLIENTS: Readonly<Record<string, string>> =
+  Object.freeze({});
+
+/**
+ * Fail fast when a surface lost its spec (it has no endpoints any more) while a
+ * previously generated client package for that surface is still on disk with
+ * generated endpoints in it.
+ *
+ * Skipping such a surface silently — which is what the plain
+ * `if (!existsSync(specPath)) continue` did — leaves a package that still
+ * builds, still publishes and still exports operations the service no longer
+ * classifies into that surface. That is dead code the generator can neither
+ * refresh nor prune, so it must be an error the operator resolves (delete or
+ * deprecate the package), not a warning.
+ *
+ * Guarded by `surfacesWithSpec.length > 0`: when the service has NO spec at all
+ * the caller simply has not run `xema-openapi` yet, which is a different (and
+ * not-an-orphan) situation.
+ *
+ * {@link KNOWN_ORPHANED_SURFACE_CLIENTS} is the escape hatch for an orphan the
+ * generator genuinely cannot resolve. It is EMPTY — the backlog this guard
+ * originally uncovered has been worked off — so today every orphan is a hard
+ * error. See that constant before adding to it.
+ */
+function assertNoOrphanedSurfaceClients(
+  ctx: ResolvedServiceContext,
+  surfacesWithSpec: readonly ApiSurface[],
+): void {
+  if (surfacesWithSpec.length === 0) {
+    return;
+  }
+  const orphans = ALL_SURFACES.filter(
+    (surface) =>
+      !surfacesWithSpec.includes(surface) &&
+      existsSync(join(surfaceClientDir(ctx, surface), 'src', 'endpoints')),
+  );
+  if (orphans.length === 0) {
+    return;
+  }
+
+  const baselined = orphans.filter((surface) =>
+    Object.hasOwn(
+      KNOWN_ORPHANED_SURFACE_CLIENTS,
+      `${ctx.api.serviceId}:${surface}`,
+    ),
+  );
+  const blocking = orphans.filter((surface) => !baselined.includes(surface));
+
+  for (const surface of baselined) {
+    const key = `${ctx.api.serviceId}:${surface}`;
+
+    console.warn(
+      `[xema-client-generate] KNOWN ORPHAN ${key} — ${surfaceClientDir(ctx, surface)} ` +
+        `is stale and will not be regenerated. ${KNOWN_ORPHANED_SURFACE_CLIENTS[key]}`,
+    );
+  }
+
+  if (blocking.length === 0) {
+    return;
+  }
+  throw new Error(
+    `api-client-generator: ${ctx.api.serviceId} emits no spec for surface(s) ` +
+      `${blocking.join(', ')}, but a generated client package still exists at ` +
+      `${blocking.map((s) => surfaceClientDir(ctx, s)).join(', ')}. That client ` +
+      `is orphaned — it would keep exporting operations the surface no longer ` +
+      `has. Delete the package (and its workspace consumers) or restore the ` +
+      `surface classification.`,
+  );
+}
+
+/**
+ * Generate (and compile) one ORVAL client package per surface that has an
+ * emitted spec. Surfaces without a spec are skipped — no empty packages. All
+ * generated clients share the service version (stamped by
+ * {@link ensureClientPackage}).
+ *
+ * @returns the surfaces that were generated.
+ */
+export async function generateClientsForService(
+  serviceDir: string = process.cwd(),
+): Promise<ApiSurface[]> {
+  const ctx: ResolvedServiceContext = resolveServiceContext(serviceDir);
+  const generate = await resolveOrvalGenerate(ctx.serviceDir);
+
+  const surfacesWithSpec = ALL_SURFACES.filter((s) =>
+    existsSync(surfaceSpecPath(ctx, s)),
+  );
+  assertNoOrphanedSurfaceClients(ctx, surfacesWithSpec);
+
+  const generated: ApiSurface[] = [];
+  for (const surface of surfacesWithSpec) {
+    const specPath = surfaceSpecPath(ctx, surface);
+    const { clientDir, clientSrc } = ensureClientPackage(ctx, surface);
+    ensureClientReadme({
+      clientDir,
+      packageName: surfaceClientPackageName(ctx.api.serviceId, surface),
+      serviceTitle: ctx.api.title,
+      surface,
+      repoRoot: ctx.repoRoot,
+    });
+    // Clean prior generated output so endpoints/models removed from this
+    // surface's spec (e.g. routes reclassified to another surface) don't linger
+    // as stale files — orval does not prune removed operations.
+    rmSync(join(clientSrc, 'endpoints'), { recursive: true, force: true });
+    rmSync(join(clientSrc, 'models'), { recursive: true, force: true });
+    await generate(orvalConfigFor(specPath, clientSrc));
+    postProcessClient(ctx.repoRoot, ctx.serviceDir, clientSrc);
+    // `tsc` is additive: it emits for the sources it sees and NEVER deletes an
+    // output whose source disappeared. Without this, every operation ever
+    // generated into this surface survives in `dist/` forever — so a route
+    // reclassified to another surface keeps a stale `.js` + `.d.ts` in the old
+    // client. Consumers then type-check GREEN against a symbol the surface no
+    // longer has, the published tarball (`files: ["dist"]`) ships endpoints the
+    // spec does not contain, and the breakage only appears on a clean
+    // checkout/CI where `dist` starts empty. Pruning `dist` alongside
+    // `src/endpoints` + `src/models` keeps the compiled output a faithful image
+    // of the spec.
+    rmSync(join(clientDir, 'dist'), { recursive: true, force: true });
+    // Compile to dist using the client package's own tsconfig.
+    execFileSync('pnpm', ['exec', 'tsc', '-p', 'tsconfig.json'], {
+      cwd: clientDir,
+      stdio: 'inherit',
+    });
+    generated.push(surface);
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(
+    `[xema-client-generate] ${ctx.api.serviceId}: generated ${
+      generated.length
+    } client(s) → ${generated.join(', ') || '(none)'}`,
+  );
+  return generated;
+}
+
+/** CLI entry: generate clients from cwd; exit non-zero on failure. */
+export function runClientGenerateCli(): void {
+  generateClientsForService()
+    .then(() => process.exit(0))
+    .catch((err: unknown) => {
+      console.error('[xema-client-generate] generation failed:', err);
+      process.exit(1);
+    });
+}

package/src/lib/overrides.ts

@@ -0,0 +1,81 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { TestingModuleBuilder } from '@nestjs/testing';
+
+/**
+ * Layer 3 of the DI-stub strategy: the optional per-service escape hatch. Most
+ * services need none of this — the universal env seed (Layer 1) + convention
+ * stubs (Layer 2) cover them. A service with a bespoke provider that boots at
+ * import/compile time ships an `openapi.overrides.ts` at its root:
+ *
+ * ```ts
+ * // <service>/openapi.overrides.ts
+ * import type { OpenApiOverrides } from '@xemahq/api-client-generator';
+ * export default {
+ *   env: { SOME_CUSTOM_VAR: 'dummy' },
+ *   applyOverrides: (builder) => builder.overrideProvider(WeirdSvc).useValue({ … }),
+ * } satisfies OpenApiOverrides;
+ * ```
+ */
+export interface OpenApiOverrides {
+  /** Extra dummy env vars seeded before `AppModule` is imported. */
+  readonly env?: Record<string, string>;
+  /**
+   * Hook applied to the `Test.createTestingModule(...)` builder AFTER the
+   * default convention stubs, so a service can override a default or stub an
+   * extra provider. Return the builder (or void — it is mutated in place).
+   */
+  readonly applyOverrides?: (
+    builder: TestingModuleBuilder,
+  ) => TestingModuleBuilder | void;
+}
+
+const OVERRIDES_BASENAME = 'openapi.overrides';
+
+/**
+ * Load `<serviceDir>/openapi.overrides.ts` (or `.js`) if present. Returns
+ * `undefined` when absent — the common case. Throws if the file exists but
+ * exports a malformed shape (fail-fast; no silent ignore).
+ */
+export function loadServiceOverrides(
+  serviceDir: string,
+): OpenApiOverrides | undefined {
+  const candidate = [`${OVERRIDES_BASENAME}.ts`, `${OVERRIDES_BASENAME}.js`]
+    .map((f) => join(serviceDir, f))
+    .find((p) => existsSync(p));
+  if (!candidate) {
+    return undefined;
+  }
+
+  const loaded: unknown = require(candidate);
+  if (loaded === null || typeof loaded !== 'object') {
+    throw new Error(
+      `api-client-generator: ${candidate} must export an overrides object.`,
+    );
+  }
+  const selected =
+    'default' in loaded &&
+    loaded.default !== null &&
+    typeof loaded.default === 'object'
+      ? loaded.default
+      : loaded;
+  const overrides = Object.fromEntries(Object.entries(selected));
+  if (
+    overrides.env !== undefined &&
+    (typeof overrides.env !== 'object' || overrides.env === null)
+  ) {
+    throw new Error(
+      `api-client-generator: ${candidate} \`env\` must be a Record<string,string>.`,
+    );
+  }
+  if (
+    overrides.applyOverrides !== undefined &&
+    typeof overrides.applyOverrides !== 'function'
+  ) {
+    throw new Error(
+      `api-client-generator: ${candidate} \`applyOverrides\` must be a function.`,
+    );
+  }
+  return overrides;
+}

package/src/lib/repo-post-process.ts

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Bridge to the repository's existing `tooling/codegen` ORVAL post-processors.
+ * The generator reuses them (rather than re-implementing) so the generated
+ * client is byte-identical to what `scripts/build-client-index.js` produced
+ * today — same barrel, same fixers, same arguments.
+ */
+
+interface PostProcessors {
+  regenerateModelsBarrel: (clientSrc: string) => number;
+  fixOrvalResponseTypes: (serviceRoot: string) => number;
+  fixOrvalArrayParams: (clientSrc: string) => number;
+}
+
+function requireRepoTool(repoRoot: string, file: string): unknown {
+  const path = join(repoRoot, 'tooling', 'codegen', file);
+  if (!existsSync(path)) {
+    throw new Error(
+      `api-client-generator: required post-processor ${path} not found. The ` +
+        `repo must ship tooling/codegen/${file}.`,
+    );
+  }
+
+  return require(path);
+}
+
+export function loadRepoPostProcessors(repoRoot: string): PostProcessors {
+  const { regenerateModelsBarrel } = requireRepoTool(
+    repoRoot,
+    'regenerate-models-barrel.js',
+  ) as { regenerateModelsBarrel: (c: string) => number };
+  const { fixOrvalResponseTypes } = requireRepoTool(
+    repoRoot,
+    'fix-orval-response-types.js',
+  ) as { fixOrvalResponseTypes: (r: string) => number };
+  const { fixOrvalArrayParams } = requireRepoTool(
+    repoRoot,
+    'fix-orval-array-params.js',
+  ) as { fixOrvalArrayParams: (c: string) => number };
+  return { regenerateModelsBarrel, fixOrvalResponseTypes, fixOrvalArrayParams };
+}
+
+/**
+ * Rebuild `<clientSrc>/index.ts` — the barrel re-exporting custom-fetch +
+ * models + every tags-split endpoint file. Identical to the loop in the legacy
+ * per-service `build-client-index.js`.
+ */
+function rebuildIndexBarrel(clientSrc: string): number {
+  const lines = [
+    '// Auto-generated by @xemahq/api-client-generator — do not edit manually.',
+    "export { configureClient, getClientConfig, ClientError, customFetch, type ClientConfig } from './custom-fetch';",
+  ];
+
+  const modelsIndex = join(clientSrc, 'models', 'index.ts');
+  if (existsSync(modelsIndex)) {
+    const content = readFileSync(modelsIndex, 'utf8');
+    if (/^export /m.test(content)) {
+      lines.push("export * from './models';");
+    }
+  }
+
+  const endpointsDir = join(clientSrc, 'endpoints');
+  if (existsSync(endpointsDir)) {
+    for (const entry of readdirSync(endpointsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const files = readdirSync(join(endpointsDir, entry.name));
+      const tsFile = files.find(
+        (f) => f.endsWith('.ts') && !f.endsWith('.d.ts'),
+      );
+      if (tsFile) {
+        lines.push(
+          `export * from './endpoints/${entry.name}/${tsFile.replace('.ts', '')}';`,
+        );
+      }
+    }
+  }
+
+  lines.push('');
+  writeFileSync(join(clientSrc, 'index.ts'), lines.join('\n'));
+  return lines.length - 2;
+}
+
+/**
+ * Run the full post-ORVAL pipeline for one generated client, mirroring the
+ * legacy `build-client-index.js` ordering exactly: models barrel → index
+ * barrel → response-type fix → array-param fix.
+ *
+ * `serviceRoot` is passed to `fixOrvalResponseTypes` unchanged from the legacy
+ * call site (it resolves its own models path internally), so the output is
+ * identical to today's pipeline.
+ */
+export function postProcessClient(
+  repoRoot: string,
+  serviceRoot: string,
+  clientSrc: string,
+): void {
+  const tools = loadRepoPostProcessors(repoRoot);
+  tools.regenerateModelsBarrel(clientSrc);
+  rebuildIndexBarrel(clientSrc);
+  tools.fixOrvalResponseTypes(serviceRoot);
+  tools.fixOrvalArrayParams(clientSrc);
+}

package/src/lib/seed-openapi-env.ts

@@ -0,0 +1,137 @@
+/**
+ * Layer 1 of the DI-stub strategy: seed deterministic dummy env vars BEFORE
+ * the service's `AppModule` is imported. NestJS modules read `process.env` at
+ * import time, so this MUST run first.
+ *
+ * Every value is a throwaway placeholder. `app.init()` is deliberately skipped
+ * during extraction, so nothing here is ever dialed — the values only need to
+ * exist so import-time `getOrThrow`/`new URL(...)` calls don't crash.
+ *
+ * This is the union of the seeds the 41 hand-written `extract-openapi.ts`
+ * scripts set. A service that reads an env var not covered here adds it via the
+ * optional per-service `openapi.overrides.ts` `env` field (Layer 3) — the
+ * generator never silently invents a value it wasn't told about beyond this
+ * shared baseline.
+ */
+
+const DUMMY_ENCRYPTION_KEY_HEX =
+  '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+const DUMMY_BASE64_KEY = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=';
+
+/** Set a default only if the var is unset (`??=` semantics). */
+function seed(vars: Record<string, string>): void {
+  for (const [key, value] of Object.entries(vars)) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+}
+
+/** The throwaway database every extraction points at. Never dialed. */
+const SCRATCH_DB_NAME = 'dummy_openapi';
+
+/**
+ * Per-service scratch Postgres schema.
+ *
+ * Extraction is run in PARALLEL by turbo across ~40 services. If they all point
+ * at one database AND one `public` schema they share a single
+ * `_prisma_migrations` table, so any code path that migrates at DI-construction
+ * time interleaves foreign migration histories and wedges its neighbours. Giving
+ * each service its own schema makes the scratch surfaces disjoint by
+ * construction. Postgres identifiers are lower-cased and capped at 63 bytes.
+ */
+export function openApiScratchSchema(serviceId: string): string {
+  return `extract_${serviceId.replace(/[^a-zA-Z0-9]+/g, '_')}`
+    .toLowerCase()
+    .slice(0, 63);
+}
+
+/**
+ * @param serviceId the `xema.api.serviceId` of the service being extracted —
+ *   used to derive a scratch schema unique to this extraction process.
+ */
+export function seedOpenApiEnv(serviceId: string): void {
+  const schema = openApiScratchSchema(serviceId);
+  seed({
+    NODE_ENV: 'development',
+
+    // Extraction-mode flag. `XemaServiceModule` eagerly resolves peer URLs from
+    // the KernelState/etcd registry at DI-construction time; with no live cluster
+    // that throws and the module can't even be constructed for scanning. Setting
+    // this makes the SDK's construction-time resolvers (`resolveHttpUrlEagerly`)
+    // short-circuit to a non-routable `.invalid` stub. The var NAME is the
+    // service-registry-nest `OPENAPI_EXTRACTION_ENV_VAR` contract; the SDK is a
+    // higher layer, so we set the env by name rather than import it here.
+    XEMA_OPENAPI_EXTRACTION: '1',
+
+    // Database (Prisma + raw pools). The scratch schema is per-service — see
+    // `openApiScratchSchema`. `DB_SCHEMA` is NOT redundant with the URL's
+    // `?schema=`: `createBiomePrismaAdapterFromEnv` passes it as the adapter's
+    // second-arg `{ schema }`, while `?schema=` is what a Prisma CLI/migrate
+    // invocation reads.
+    DATABASE_URL: `postgresql://dummy:dummy@localhost:5432/${SCRATCH_DB_NAME}?schema=${schema}`,
+    DB_HOST: 'localhost',
+    DB_PORT: '5432',
+    DB_NAME: SCRATCH_DB_NAME,
+    DB_SCHEMA: schema,
+    DB_USER: 'dummy',
+    DB_PASSWORD: 'dummy',
+    REDIS_URL: 'redis://localhost:6379',
+    OPENSEARCH_URL: 'http://localhost:9200',
+
+    // Identity / auth.
+    IDENTITY_API_URL: 'http://localhost:3053',
+    IDENTITY_API_INTERNAL_TOKEN: 'dummy-token',
+    JWT_PUBLIC_KEY_URL:
+      'http://localhost:8180/realms/dummy/protocol/openid-connect/certs',
+    JWT_ISSUER: 'http://localhost:8180/realms/dummy',
+    GATEWAY_JWT_SECRET: 'dummy-gateway-jwt-secret-for-openapi-extraction',
+    SHARE_TOKEN_SECRET: 'dummy-share-token-secret',
+    OPENCODE_WORKER_PASSWORD: 'dummy-worker-password',
+
+    // Service registry (etcd-only autodiscovery). `createKernelState` fail-fasts
+    // without this; the etcd3 client is lazy (no dial until first call) and
+    // extraction skips `app.init()`, so the dummy endpoint is never contacted.
+    XEMA_ETCD_ENDPOINTS: 'localhost:2379',
+
+    // Event hub. `WEBHOOK_URL` is the delivery callback every service that
+    // SUBSCRIBES declares to `EventHubModule.forRootAsync` — it is boot-REQUIRED
+    // (`getOrThrow`) in ~20 services, so it belongs in the shared baseline
+    // rather than being re-declared in ~20 `openapi.overrides.ts` files.
+    EVENT_HUB_URL: 'http://localhost:3128',
+    WEBHOOK_URL: 'http://localhost:3000/webhooks/events',
+
+    // Cross-service HTTP URLs (resolved via the registry in prod; dummy here).
+    BACKLOG_API_URL: 'http://localhost:3100',
+    MEMORY_API_URL: 'http://localhost:3060',
+    LLM_REGISTRY_API_URL: 'http://localhost:3112',
+    LLM_GATEWAY_API_URL: 'http://localhost:3110',
+    ARTIFACT_STORE_API_URL: 'http://localhost:3130',
+    KNOWLEDGE_BASE_API_URL: 'http://localhost:3200',
+    PROJECT_REGISTRY_API_URL: 'http://localhost:3300',
+    CONNECTOR_GATEWAY_API_URL: 'http://localhost:3900',
+    DESIGN_SYSTEM_BUILDER_API_URL: 'http://localhost:3210',
+    SEARCH_API_URL: 'http://localhost:3220',
+    BILLING_API_URL: 'http://localhost:3140',
+    CAPABILITY_REGISTRY_API_URL: 'http://localhost:3700',
+
+    // SCM / git.
+    SCM_WEBHOOK_SECRET: 'dummy-webhook-secret',
+    SCM_WEBHOOK_BASE_URL: 'http://localhost:3500/webhooks',
+    GITEA_URL: 'http://localhost:3000',
+    GITEA_ADMIN_USER: 'gitea_admin',
+    GITEA_ADMIN_PASS: 'gitea_admin_pass',
+
+    // Encryption keys (hex 32-byte + base64 variants used across services).
+    MASTER_ENCRYPTION_KEY: DUMMY_ENCRYPTION_KEY_HEX,
+    ENCRYPTION_MASTER_KEY: DUMMY_BASE64_KEY,
+    LLM_REGISTRY_ENCRYPTION_KEY:
+      'abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789',
+    VARIABLE_ENCRYPTION_KEY:
+      'fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210',
+
+    // Platform observability endpoints.
+    PLATFORM_METRICS_ENDPOINT: 'http://localhost:9090/metrics',
+    PLATFORM_AUDIT_ENDPOINT: 'http://localhost:3601/audit',
+  });
+}