@aifabrix/builder 2.43.0 → 2.44.0

package/lib/utils/url-declarative-resolve-load-doc.js

@@ -0,0 +1,51 @@
+/**
+ * Load application.yaml for url:// resolution (current app via variablesPath, else builder-relative).
+ * @fileoverview
+ */
+'use strict';
+
+const path = require('path');
+const yaml = require('js-yaml');
+const fsRealSync = require('../internal/fs-real-sync');
+
+/**
+ * @param {string} appKey
+ * @param {Object} ctx
+ * @param {object} pathsUtil - paths module (getProjectRoot)
+ * @returns {object|null}
+ */
+function loadApplicationYamlDocForUrlResolve(appKey, ctx, pathsUtil) {
+  try {
+    const current = ctx.currentAppKey || '';
+    if (appKey === current && ctx.variablesPath) {
+      const vp = path.resolve(String(ctx.variablesPath));
+      try {
+        const raw = fsRealSync.readFileSync(vp, 'utf8');
+        const doc = yaml.load(raw);
+        if (doc && typeof doc === 'object') {
+          return doc;
+        }
+      } catch {
+        // Fall through to builder-relative resolution
+      }
+    }
+    const root = pathsUtil.getProjectRoot();
+    if (!root) {
+      return null;
+    }
+    const cfgPath = path.resolve(path.join(root, 'builder', appKey, 'application.yaml'));
+    try {
+      const raw = fsRealSync.readFileSync(cfgPath, 'utf8');
+      const doc = yaml.load(raw);
+      return doc && typeof doc === 'object' ? doc : null;
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  loadApplicationYamlDocForUrlResolve
+};

package/lib/utils/url-declarative-resolve.js

@@ -0,0 +1,220 @@
+/**
+ * Expand url:// placeholders after kv:// (plan 122): full URL, host-only (origin), and vdir (path) variants.
+ *
+ * @fileoverview Dual profile docker|local; devNN host only via Traefik + frontDoorRouting.host (plan 122)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fsRealSync = require('../internal/fs-real-sync');
+const path = require('path');
+const yaml = require('js-yaml');
+const { deriveEnvKeyFromClientId } = require('./derive-env-key-from-client-id');
+const { parseDeveloperIdNum } = require('./declarative-url-ports');
+const { computeDeclarativePathPrefix } = require('./url-declarative-url-flags');
+const { refreshUrlsLocalRegistryFromBuilder, normalizePatternForUrl } = require('./urls-local-registry');
+const pathsUtil = require('./paths');
+const { parseUrlToken } = require('./url-declarative-token-parse');
+const {
+  applyTstRemoteDeveloperHost,
+  applyTstRemoteDeveloperHostToOrigin,
+  buildPublicUrlString,
+  buildPublicHostOriginString,
+  buildInternalUrlString,
+  buildInternalHostOriginString,
+  expandResolvedUrlToken,
+  resolveListenPortPatternForToken
+} = require('./url-declarative-resolve-build');
+
+const URL_REF = /url:\/\/([^\s#'"]+)/g;
+
+/**
+ * Expand each `url://token` in a value (comma-separated lists, e.g. CORS ALLOWED_ORIGINS).
+ * Tokens match {@link parseUrlToken} id characters (alphanumeric, dot, underscore, hyphen).
+ *
+ * @param {string} value - RHS of KEY=value
+ * @param {function(string): string} replaceToken - receives token without `url://`
+ * @returns {string}
+ */
+function expandDeclarativeUrlListValue(value, replaceToken) {
+  if (!value || typeof value !== 'string' || !value.includes('url://')) {
+    return value;
+  }
+  return value
+    .split(',')
+    .map((raw) => {
+      const seg = raw.trim();
+      const exact = /^url:\/\/([a-zA-Z0-9._-]+)$/.exec(seg);
+      if (exact) {
+        return replaceToken(exact[1]);
+      }
+      if (seg.includes('url://')) {
+        return seg.replace(/url:\/\/([a-zA-Z0-9._-]+)/g, (_full, tok) => replaceToken(tok));
+      }
+      return seg;
+    })
+    .join(',');
+}
+
+/**
+ * @param {string} content - .env-like content
+ * @returns {Object.<string, string>}
+ */
+function parseSimpleEnvMap(content) {
+  const map = {};
+  if (!content || typeof content !== 'string') {
+    return map;
+  }
+  for (const line of content.split('\n')) {
+    const t = line.trim();
+    if (!t || t.startsWith('#')) {
+      continue;
+    }
+    const eq = t.indexOf('=');
+    if (eq > 0) {
+      const k = t.slice(0, eq).trim();
+      map[k] = t.slice(eq + 1);
+    }
+  }
+  return map;
+}
+
+/**
+ * Load application.yaml for cross-app scoped flag.
+ * @param {string} targetAppKey
+ * @returns {boolean}
+ */
+function readTargetAppScopedFlag(targetAppKey) {
+  try {
+    const appPath = pathsUtil.getBuilderPath(targetAppKey);
+    const cfgPath = path.join(appPath, 'application.yaml');
+    if (!fsRealSync.existsSync(cfgPath)) {
+      return false;
+    }
+    const doc = yaml.load(fsRealSync.readFileSync(cfgPath, 'utf8'));
+    return doc && doc.environmentScopedResources === true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve one url:// token to a concrete URL string.
+ * @param {string} token
+ * @param {Object} ctx - Same shape as expandDeclarativeUrlsInEnvContent ctx
+ * @param {'docker'|'local'} profile
+ * @param {number} devNum
+ * @param {string} derivedEnvKey
+ * @param {Object} registry
+ * @returns {string}
+ */
+function replaceUrlRefToken(token, ctx, profile, devNum, derivedEnvKey, registry) {
+  const parsed = parseUrlToken(token);
+  const resolved = resolveListenPortPatternForToken(token, ctx, registry);
+  if (!resolved) {
+    return `url://${token}`;
+  }
+  const {
+    appKey,
+    listenPort,
+    publicPortBasis,
+    patternStr,
+    hostTemplate,
+    tls,
+    frontDoorIngressActive
+  } = resolved;
+  const patternPath = normalizePatternForUrl(patternStr);
+  const appScoped = parsed.targetKey
+    ? readTargetAppScopedFlag(parsed.targetKey)
+    : Boolean(ctx.appEnvironmentScopedResources);
+  const pathPrefix = computeDeclarativePathPrefix(
+    Boolean(ctx.traefik),
+    ctx.useEnvironmentScopedResources,
+    appScoped,
+    derivedEnvKey
+  );
+  return expandResolvedUrlToken(parsed, {
+    profile,
+    listenPort,
+    publicPortBasis,
+    appKey,
+    currentAppKey: ctx.currentAppKey || '',
+    patternPath,
+    pathPrefix,
+    remoteServer: ctx.remoteServer,
+    devNum,
+    derivedEnvKey,
+    traefik: Boolean(ctx.traefik),
+    hostTemplate,
+    tls,
+    frontDoorIngressActive,
+    developerIdRaw: ctx.developerIdRaw,
+    infraTlsEnabled: Boolean(ctx.infraTlsEnabled)
+  });
+}
+
+/**
+ * Expand url:// references in env content (after kv://).
+ *
+ * @async
+ * @param {string} content
+ * @param {Object} ctx
+ * @param {'docker'|'local'} ctx.profile
+ * @param {string} ctx.currentAppKey
+ * @param {string|null} ctx.variablesPath
+ * @param {boolean} ctx.useEnvironmentScopedResources
+ * @param {boolean} ctx.appEnvironmentScopedResources
+ * @param {string|null|undefined} ctx.remoteServer
+ * @param {string|number|null|undefined} ctx.developerIdRaw
+ * @param {boolean} [ctx.traefik] - Infra Traefik proxy on. Plan 117 `/dev`/`/tst` applies only when this is true. Traefik **host** authority (`frontDoorRouting.host`) applies only when this is true **and** the target app has `frontDoorRouting.enabled: true` (plan 124 `pathActive`).
+ * @param {boolean} [ctx.infraTlsEnabled] - When true (`tlsEnabled` in config / `up-infra --tls`), Traefik front-door `url://public` uses https even if application.yaml has `frontDoorRouting.tls: false`
+ * @returns {Promise<string>}
+ */
+async function expandDeclarativeUrlsInEnvContent(content, ctx) {
+  if (!content || !content.includes('url://')) {
+    return content;
+  }
+  const profile = ctx.profile === 'docker' ? 'docker' : 'local';
+  const devNum = parseDeveloperIdNum(ctx.developerIdRaw);
+  const envMap = parseSimpleEnvMap(content);
+  const clientId = envMap.MISO_CLIENTID;
+  const pipelineOverride = envMap.MISO_PIPELINE_ENV_KEY;
+  const derivedEnvKey = deriveEnvKeyFromClientId(clientId, pipelineOverride);
+  const registry = refreshUrlsLocalRegistryFromBuilder(pathsUtil.getProjectRoot());
+
+  const lines = content.split('\n');
+  const outLines = lines.map((line) => {
+    const t = line.trim();
+    if (!t || t.startsWith('#') || !line.includes('url://')) {
+      return line;
+    }
+    const eq = line.indexOf('=');
+    if (eq <= 0) {
+      return line.replace(URL_REF, (_m, token) =>
+        replaceUrlRefToken(token, ctx, profile, devNum, derivedEnvKey, registry)
+      );
+    }
+    const keyPart = line.slice(0, eq);
+    const valuePart = line.slice(eq + 1);
+    const expandedValue = expandDeclarativeUrlListValue(valuePart, (token) =>
+      replaceUrlRefToken(token, ctx, profile, devNum, derivedEnvKey, registry)
+    );
+    return `${keyPart}=${expandedValue}`;
+  });
+  return outLines.join('\n');
+}
+
+module.exports = {
+  expandDeclarativeUrlsInEnvContent,
+  expandDeclarativeUrlListValue,
+  parseSimpleEnvMap,
+  applyTstRemoteDeveloperHost,
+  applyTstRemoteDeveloperHostToOrigin,
+  buildPublicUrlString,
+  buildPublicHostOriginString,
+  buildInternalUrlString,
+  buildInternalHostOriginString,
+  parseUrlToken
+};

package/lib/utils/url-declarative-token-parse.js

@@ -0,0 +1,74 @@
+/**
+ * Declarative url:// token shape parsing (plan 122/124).
+ * Single module for suffix lists and parseUrlToken — avoids drift with tests.
+ *
+ * @fileoverview parseUrlToken only; no URL expansion
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * Current-app tokens (no appKey prefix).
+ * @type {readonly { id: string, kind: 'public'|'internal', surface: 'full'|'host'|'vdir' }[]}
+ */
+const DECLARATIVE_URL_EXACT_TOKENS = Object.freeze([
+  { id: 'host-public', kind: 'public', surface: 'host' },
+  { id: 'host-internal', kind: 'internal', surface: 'host' },
+  { id: 'host-private', kind: 'internal', surface: 'host' },
+  { id: 'vdir-public', kind: 'public', surface: 'vdir' },
+  { id: 'vdir-internal', kind: 'internal', surface: 'vdir' },
+  { id: 'vdir-private', kind: 'internal', surface: 'vdir' },
+  { id: 'public', kind: 'public', surface: 'full' },
+  { id: 'internal', kind: 'internal', surface: 'full' },
+  { id: 'private', kind: 'internal', surface: 'full' }
+]);
+
+/**
+ * Cross-app suffixes (longest match first). App key is token prefix before suffix.
+ * @type {readonly { suffix: string, kind: 'public'|'internal', surface: 'full'|'host'|'vdir' }[]}
+ */
+const DECLARATIVE_URL_CROSS_APP_SUFFIXES = Object.freeze([
+  { suffix: '-host-public', kind: 'public', surface: 'host' },
+  { suffix: '-host-internal', kind: 'internal', surface: 'host' },
+  { suffix: '-host-private', kind: 'internal', surface: 'host' },
+  { suffix: '-vdir-public', kind: 'public', surface: 'vdir' },
+  { suffix: '-vdir-internal', kind: 'internal', surface: 'vdir' },
+  { suffix: '-vdir-private', kind: 'internal', surface: 'vdir' }
+]);
+
+const URL_TOKEN_EXACT = new Map(DECLARATIVE_URL_EXACT_TOKENS.map((d) => [d.id, { kind: d.kind, surface: d.surface }]));
+
+/**
+ * @param {string} token
+ * @returns {{ targetKey: string, kind: 'public'|'internal', surface: 'full'|'host'|'vdir' }}
+ */
+function parseUrlToken(token) {
+  const t = String(token || '').trim();
+  const exact = URL_TOKEN_EXACT.get(t);
+  if (exact) {
+    return { targetKey: '', kind: exact.kind, surface: exact.surface };
+  }
+  for (const { suffix, kind, surface } of DECLARATIVE_URL_CROSS_APP_SUFFIXES) {
+    if (t.endsWith(suffix)) {
+      return { targetKey: t.slice(0, -suffix.length), kind, surface };
+    }
+  }
+  if (t.endsWith('-public')) {
+    return { targetKey: t.slice(0, -'-public'.length), kind: 'public', surface: 'full' };
+  }
+  if (t.endsWith('-internal')) {
+    return { targetKey: t.slice(0, -'-internal'.length), kind: 'internal', surface: 'full' };
+  }
+  if (t.endsWith('-private')) {
+    return { targetKey: t.slice(0, -'-private'.length), kind: 'internal', surface: 'full' };
+  }
+  return { targetKey: '', kind: 'public', surface: 'full' };
+}
+
+module.exports = {
+  DECLARATIVE_URL_EXACT_TOKENS,
+  DECLARATIVE_URL_CROSS_APP_SUFFIXES,
+  parseUrlToken
+};

package/lib/utils/url-declarative-url-flags.js

@@ -0,0 +1,50 @@
+/**
+ * Centralized declarative url:// flags (plan 124 truth table).
+ *
+ * @fileoverview pathActive, pathPrefix gating — single source for resolver + tests
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { computePublicUrlPathPrefix } = require('./url-public-path-prefix');
+
+/**
+ * pathActive = traefik on AND application.yaml frontDoorRouting.enabled === true
+ * @param {boolean} traefik
+ * @param {boolean} [frontDoorRoutingEnabled]
+ * @returns {boolean}
+ */
+function computePathActive(traefik, frontDoorRoutingEnabled) {
+  return Boolean(traefik) && frontDoorRoutingEnabled === true;
+}
+
+/**
+ * Plan 117 /dev|/tst prefix only when Traefik proxy is on; otherwise '' (plan 124).
+ * @param {boolean} traefik
+ * @param {boolean} useEnvironmentScopedResources
+ * @param {boolean} appEnvironmentScopedResources
+ * @param {string} derivedEnvKey
+ * @returns {string}
+ */
+function computeDeclarativePathPrefix(
+  traefik,
+  useEnvironmentScopedResources,
+  appEnvironmentScopedResources,
+  derivedEnvKey
+) {
+  if (!traefik) {
+    return '';
+  }
+  return computePublicUrlPathPrefix(
+    useEnvironmentScopedResources,
+    appEnvironmentScopedResources,
+    derivedEnvKey
+  );
+}
+
+module.exports = {
+  computePathActive,
+  computeDeclarativePathPrefix
+};

package/lib/utils/url-declarative-vdir-inactive-env.js

@@ -0,0 +1,99 @@
+/**
+ * Rewrite env lines that hold the declarative token url://vdir-public when the front-door
+ * path is inactive. Expansion would yield an empty path; consumers need a non-empty value,
+ * so the line is set to "/" only in that case.
+ *
+ * @fileoverview No schema or manifest keys — fixed "/" when path inactive (same token as url-declarative-resolve-build).
+ * Reads application.yaml via {@link module:lib/internal/fs-real-sync} so Jest fs mocks do not hide real files.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const yaml = require('js-yaml');
+const { existsSync, readFileSync } = require('../internal/fs-real-sync');
+const { DECLARATIVE_URL_INFRA_DEFAULTS } = require('./infra-env-defaults');
+const { computePathActive } = require('./url-declarative-url-flags');
+
+/**
+ * Treat common YAML / string forms as enabled (strict `=== true` alone missed some parsers).
+ * @param {object|null|undefined} doc
+ * @returns {boolean}
+ */
+function isFrontDoorRoutingEnabledInDoc(doc) {
+  const v = doc && doc.frontDoorRouting && doc.frontDoorRouting.enabled;
+  return v === true || v === 'true' || v === 'yes' || v === 'on';
+}
+
+/**
+ * Parse application.yaml from disk (real fs — not Jest-mocked require('fs')).
+ * @param {string} variablesPath
+ * @returns {object|null}
+ */
+function loadApplicationYamlDoc(variablesPath) {
+  if (!variablesPath || !existsSync(variablesPath)) {
+    return null;
+  }
+  try {
+    return yaml.load(readFileSync(variablesPath, 'utf8')) || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Declarative URL token (matches {@link module:lib/utils/url-declarative-resolve-build} vdir-public). */
+const URL_DECLARATIVE_VDIR_PUBLIC_TOKEN = 'url://vdir-public';
+
+/** Value used when front-door path is inactive (would otherwise expand empty). */
+const INACTIVE_VDIR_PUBLIC_ENV_FALLBACK =
+  DECLARATIVE_URL_INFRA_DEFAULTS.inactiveVdirPublicEnvReplacement;
+
+/**
+ * @param {string} content - .env template fragment
+ * @param {string} replacement
+ * @returns {string}
+ */
+function applyInactiveVdirPublicTokenRewrite(content, replacement) {
+  if (!content || !content.includes(URL_DECLARATIVE_VDIR_PUBLIC_TOKEN)) {
+    return content;
+  }
+  const escaped = URL_DECLARATIVE_VDIR_PUBLIC_TOKEN.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // End line with [ \t]* only — \s would consume \n and strip line endings from the file.
+  const lineRe = new RegExp(`^(\\s*[A-Z][A-Z0-9_]*)\\s*=\\s*${escaped}[ \t]*$`, 'gm');
+  return content.replace(lineRe, (_, lhs) => `${lhs}=${replacement}`);
+}
+
+/**
+ * Load application.yaml, compute pathActive, rewrite matching lines to "/" when inactive.
+ * @param {string} content
+ * @param {string|null|undefined} variablesPath
+ * @param {{ traefik?: boolean }} userCfg
+ * @returns {string}
+ */
+function rewriteInactiveDeclarativeVdirPublicContent(content, variablesPath, userCfg) {
+  if (!content || !variablesPath || !content.includes(URL_DECLARATIVE_VDIR_PUBLIC_TOKEN)) {
+    return content;
+  }
+  let doc = null;
+  try {
+    doc = loadApplicationYamlDoc(variablesPath);
+  } catch {
+    doc = null;
+  }
+  const pathActive = computePathActive(
+    Boolean(userCfg && userCfg.traefik),
+    isFrontDoorRoutingEnabledInDoc(doc)
+  );
+  if (pathActive) {
+    return content;
+  }
+  return applyInactiveVdirPublicTokenRewrite(content, INACTIVE_VDIR_PUBLIC_ENV_FALLBACK);
+}
+
+module.exports = {
+  URL_DECLARATIVE_VDIR_PUBLIC_TOKEN,
+  INACTIVE_VDIR_PUBLIC_ENV_FALLBACK,
+  applyInactiveVdirPublicTokenRewrite,
+  rewriteInactiveDeclarativeVdirPublicContent
+};

package/lib/utils/url-public-path-prefix.js

@@ -0,0 +1,34 @@
+/**
+ * Plan 117 URL path prefix for url://public (dev/tst only when gated).
+ *
+ * @fileoverview baseEffective ∧ derived envKey ∈ {dev,tst}. Caller must pass prefix only when `traefik` is on (see url-declarative-resolve).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {boolean} useEnvironmentScopedResources - config gate
+ * @param {boolean} appEnvironmentScopedResources - application.yaml
+ * @param {string} derivedEnvKey - from client id (dev|tst|pro|miso)
+ * @returns {string} '' | '/dev' | '/tst'
+ */
+function computePublicUrlPathPrefix(useEnvironmentScopedResources, appEnvironmentScopedResources, derivedEnvKey) {
+  const baseEffective = Boolean(useEnvironmentScopedResources) && Boolean(appEnvironmentScopedResources);
+  if (!baseEffective) {
+    return '';
+  }
+  const k = String(derivedEnvKey || '').toLowerCase();
+  if (k === 'dev') {
+    return '/dev';
+  }
+  if (k === 'tst') {
+    return '/tst';
+  }
+  return '';
+}
+
+module.exports = {
+  computePublicUrlPathPrefix
+};