mirror of
https://github.com/Studio-Saelix/sencho.git
synced 2026-09-02 21:58:06 +00:00
feat(git): complete-project materialization with a managed-project manifest (#1786)
* feat(git): add managed-project manifest types and DB cache columns
Introduces the canonical managed-project manifest contract types (schema v1)
and the stack_git_sources cache columns manifest_version / manifest_state /
manifest_generation. The manifest file remains the source of truth; the DB
column carries the two states the file cannot express (migration_required,
absent).
* feat(git): add vendored Docker .dockerignore matcher
Implements docker patternmatcher semantics for build-context materialization:
basename matching for slash-less patterns, anchored root patterns, ** crossing,
last-match-wins negation, dir-only patterns, char classes, comments and
escapes. Table-driven tests cover the full rule set.
* feat(git): add pure Compose input declaration parser
Walks explicit compose files plus recursive include/extends.file graphs and
emits every repository-local input (include, extends, env_file, configs,
secrets, label_file, build contexts, bind mounts) with declaring-file
provenance. Side-effect free: file contents are injected via a read callback.
Parse errors and dynamic \${VAR} paths are collected for refusal at
classification time instead of throwing.
* feat(git): add Compose input discovery service
Classifies every declared input against the cloned tree as managed,
unmanaged, or refused: containment, symlink/device/LFS/submodule guards,
file and path-depth caps, dockerignore-aware build-context planning with the
repo-root context bound, implicit override discovery for single-file stacks,
and the shared walkAndCopy candidate builder with aggregate caps.
* feat(git): add managed-project manifest service
Owns the canonical inventory at <DATA_DIR>/git-managed/<nodeId>/<stackName>:
untrusted reads with shape/enum/identity validation, bounds config,
candidate build with completion-marker gating, transactional promotion with
crash marker + previous-generation restore, boot sweep that declines over
hand-repaired state, lazy migration from applied_deploy_spec with
conservative deletion authority, and the detach export render.
* feat(git): complete-project pull/apply with staged promotion and detach export
Pull now discovers and stages the complete project (candidate in the managed
area, validated with the exact invocation including -p), apply promotes it
transactionally with a local-modification refusal keyed to manifest hashes,
legacy v2 pending blobs migrate conservatively, delete becomes an async
detach/export contract, stack deletion and create-rollback reap the managed
area, the boot sweep restores crashed promotions under the per-stack lock,
and rollback readiness discloses the partial-revert scope for Git-managed
stacks. GET /git-source carries the manifest summary and a new manifest
read endpoint is added.
* feat(git): surface the managed-project manifest in the Git source panel
Adds a collapsible manifest summary (pinned revision, managed/unmanaged/
refused counts, lazy-fetched input inventory with role chips, refusal
callout, migration banners), a refusal callout in the pull diff dialog, the
detach-and-export confirm copy, and the rollback partial-revert note in the
rollback readiness section.
* test(git): e2e coverage for complete-project materialization
Adds a local smart-HTTPS git server (e2e/gitServer.helper.ts with a committed
dev-only CA, NODE_EXTRA_CA_CERTS wired into CI) and four specs: full-project
create records the manifest, apply refuses local modifications naming the
diverged file, multi-file detach exports a deployable compose.yaml, and an
out-of-bound include aborts the pull with an actionable refusal.
* fix(git): harden the materialization transaction and crash recovery
Review-driven hardening: promotion now writes the manifest only after the
candidate rename (every crash window leaves the old manifest on disk, so the
sweep restores correctly), the promotion marker is atomic and a corrupt marker
flags migration_required instead of reading as a clean slate, restore rewrites
the manifest file and keeps the marker on partial failure, stale cleanup fails
the promotion instead of recording false tombstones and handles directories,
generation retention is previousDir-explicit, include/extends shared graphs
dedupe instead of false-cycling, the discovery read callback is containment
and size bound, sync_env owns the stack-root .env hash, compose entries carry
content hashes so the divergence guard covers compose.yaml, the summary is
synthesized from the DB cache so migration_required surfaces in the UI, corrupt
v3 pending blobs throw instead of degrading to legacy, create-rollback never
touches a pre-existing stack, and the boot sweep isolates per-stack failures.
* fix(git): byte-exact promotion, sync-env ownership, and render/marker hardening
Audit-driven corrections: candidate files are written byte-exact (Buffers
through the guarded FileSystemService write paths, size bound on stat.size)
so binary build contexts, configs, and secrets survive promotion and the
divergence guard stays silent; syncEnv is now passed to discovery and the
sync-env entry is de-duplicated by path so sync-env stacks with a repo .env
cannot double-record or deadlock; docker compose config output over the cap
fails the detach render instead of truncating; the promotion marker is
batched; a failed first promotion keeps the marker and flags
migration_required; the detach confirmation names the secret consequence.
Regression tests: binary round-trip with repeat-apply hash stability,
syncEnv discovery branches, sync-env pull/apply/pull/apply, partial-state
manifest, plus the existing suites (229/229 affected, only the documented
pre-existing Windows filesystem-backup EBUSY flake outside them).
* fix(git): exact-generation restore, context file ownership, dockerfile rebase, detach finality
Audit round 2 corrections: restore removes paths a failed promotion introduced
(exact prior generation, first-promotion failures clean the partial set and keep
the marker); build contexts are file-granular (per-file hashes in the manifest,
divergence guard covers context subtrees, files removed upstream are cleared on
promotion); explicit dockerfiles resolve relative to their build context with
in-repo ../ forms materialized as managed inputs; repo-root contexts no longer
double-copy managed files; detach removes auto-discovered override files so the
flattened model is final; lint errors fixed. Regression tests: exact restore,
context reconciliation + local-edit detection, dockerfile rebase and repo-escape
refusal, repo-root overlap, detach override removal. 213/213 affected backend
tests.
* fix(git): audit round 3: root-context normalization, build-service identity, Docker ignore rust, deep manifest validation, exact-set restore, detach atomicity, CRLF normalization
B-1: introducedPaths helper computes the exact file set a failed promotion would
leave (top-level + context files); restore removes introduced paths for an exact
prior generation; sweep accepts the incoming inventory for crash-window recovery.
B-2: repo-root context (build: .) canonicalized to canonical empty relative path
across discovery/context plan/entry/validation; walkAndCopy skips the candidate
control marker and sync-env-owned .env so root contexts never copy Sencho metadata
into the live stack dir.
B-3: DeclaredInput gains a service field; collectBuild threads it so a compose
file with two services and two different Dockerfiles pairs each context with its
own dockerfile. Additional contexts never inherit the service dockerfile.
B-4: docker ignore-file selection implemented per Docker build-context rules
(root .dockerignore, with Dockerfile-specific <name>.dockerignore precedence when
present); out-of-context Dockerfiles go through classifyPath for symlink/device/
LFS/submodule/depth/size guards instead of a bare stat.
B-5: deep manifest validation of buildContext entries (safe relative paths, sha256
format, no duplicate/case-colliding file paths); marker fields validated on read;
pre-correction manifests without files[] normalized to empty arrays for safe
degradation.
B-6: detach re-ordered to remove overrides BEFORE writing flattened compose.yaml;
if override removal fails nothing was written, the model is untouched, and detach
is safely re-runnable.
S-1: ComposeService.ts LFs normalized to repository convention.
All 213 affected backend tests pass; tsc + lint clean both sides.
* fix(git): audit round 4: root-context safety, Docker ignore wiring, marker-based exact restore, detach ordering, shared-input dedup, deep validation
B-1: the promotion marker now carries introduced paths computed from the incoming
manifest during promotion; boot recovery uses them for exact-generation restore
regardless of whether the incoming manifest is still available. `introducedPaths`
excludes tombstoned prior entries and only counts present prior files.
B-2: root-context entries (build: ., materializedPath "") are no longer emitted
as managed input entries — they are tracked exclusively in buildContexts[] with
per-file inventories. `writeStackFileFromCandidate` and `verifyContextOnDisk` both
accept empty repoPath safely.
B-3: Dockerfile-specific .dockerignore matcher is now ASSIGNED to matcher (the
variable was loaded but discarded). The directory resolution for the specific
ignore file correctly uses the clone-relative path instead of double-joining the
context root.
B-4: detach now writes the flattened compose.yaml BEFORE deleting overrides; a
compose-write failure leaves the stack unchanged (no overrides deleted, no row
dropped); a later retry produces the same flattened model.
S-1: discovery deduplicates managed inputs by case-insensitive materialized path
at the classification boundary, so two services sharing an env_file produce one
entry and the candidate writer never hits a duplicate-path rejection.
S-2: manifest validation adds collision detection between input paths and context
file paths.
All 213 affected backend tests pass; tsc clean; lint 0 errors.
* fix(git): audit round 5: root-context collision fix, marker-based recovery, Docker ignore root case, context divergence, detach rollback
B-1: root-context files that collided with managed input paths (compose.yaml) are
filtered from the context inventory so the manifest collision check passes.
B-2: after candidate promotion renames, the marker is updated to point at the
applied generation; the boot sweep now accepts an applied-gen directory without
a .candidate-complete marker as valid for recovery.
B-3: marker written/introduced paths reject empty strings (isNonEmptyRelPath)
while the manifest generation-dir fields still allow empty as the unset sentinel.
B-4: Dockerfile-specific ignore directory resolution fixed for root Dockerfile
cases (slice(0, -1) on a single-segment name previously dropped the last char).
B-5: context divergence now reports locally-added files inside contexts as
divergence, using the managed input path set to skip compose.yaml/.env/files
that have a non-context owner.
B-6: detach now snapshots the prior compose.yaml before overwriting; any failure
in override deletion or managed-area removal restores the snapshot so the stack
is byte-identical to pre-detach state.
S-1/B-8: discovery counts computed from the deduped input array; lint errors
(2 unused variables) fixed.
All 213 affected backend tests pass; tsc clean; lint 0 errors.
* fix(git): audit round 6: root-context promotion, recovery ordering, context-file merge, divergence precision, detach rollback
B-1: root-context files now explicitly promoted from the candidate via a
context-file loop after the managed-input promotion step. Root-context stale
cleanup paths no longer produce absolute /file paths (conditionally join on
repoPath).
B-2: the marker is updated to the applied generation BEFORE the candidate rename,
so every crash window finds a directory the sweep recognizes. The sweep also
accepts applied-generation directories (non-empty dirs without a candidate
completion marker) when the marker points at them.
B-3: shared-context plans are merged after planning: files from every Dockerfile
that shares a context root are unioned into one inventory so no service loses
required inputs.
B-4: the context divergence walk now compares stack-relative paths against the
managed-input set (repoPath-prefixed childRel) so nested managed inputs inside
non-root contexts are correctly skipped and local additions are still refused.
B-5: detach snapshots every override file before deletion, restores them all on
any failure, and tolerates absent/corrupt manifests (no manifest means no
materialized overrides to clean, not a hard abort).
All 213 affected backend tests pass; tsc clean; lint 0 errors.
* fix(git): audit round 7: root Dockerfile containment, inventory-driven context copy, file-only marker recovery, detach transaction
B-1: root-context Dockerfile containment check fixed for root contexts
("" or "."). Any repo-relative Dockerfile without ../ is in-context.
B-2: context copy now reads from the plan inventory (plan.context.files)
instead of re-walking the source with the first matcher. Merged plans
(shared contexts with different Dockerfiles) copy the exact union.
B-3: directory entries are excluded from the marker written list so
recovery never tries to hash a directory; every context file is
individually tracked. Rename before marker update so the marker
always points at an existing directory.
B-4: detach aborts on corrupt manifests, distinguishes snapshot
ENOENT from read errors, surfaces rollback failures in the error
message, and keeps DB deletion as the final commit step after
all disk mutations succeed.
All 213 affected backend tests pass; tsc clean; lint 0 errors.
* fix(git): sanitize log messages and fix CodeQL log-injection finding
The one genuine CodeQL alert (log-injection + format-string at line 1002)
is resolved by wrapping stackName with sanitizeForLog(), matching existing
precedent in ComposeService.ts and routes/stacks.ts. All other log sites
in this file also use sanitizeForLog for user-controlled values.
* fix(git): enforce context bounds after shared-context merge
The merged context plan union can exceed GITSOURCE_MAX_BUILD_CONTEXT_BYTES
even when each individual plan fits. Recheck the cap against the unionized
inventory after merging.
* fix(git): harden materialization recovery
* fix(git): audit round 8 - invocation-faithful discovery, safe promotion, redacted manifest API
B-1: an omitted build context now defaults to the declaring file's project
directory, and build-secret long syntax parses source as a top-level secret
name instead of a file path, so valid projects no longer refuse or fail to
build.
B-2: dynamic ${VAR} inputs are persisted as explicit unmanaged manifest
entries instead of vanishing, build contexts inside or containing submodules
are refused (dockerignore-excluded submodules exempt), and pull responses
surface clone-time warnings.
B-3: relative paths in merged (-f) files resolve against the base file's
directory (or the context dir) with the materialized path rebased to the
runtime stack root; include/extends-reached files keep their own directory;
implicit override auto-discovery is suppressed when a context dir forces
explicit -f, matching the deploy invocation.
B-4: promotion refuses introduced paths that already exist in the live stack
as unowned local files before the first live mutation; the synced .env and
fresh-stack creation stay exempt.
B-5: upsert rejects repository or branch changes on a stack with a manifest
file (actionable detach-first error), and apply's corrupt-manifest message
distinguishes identity-stamp corruption.
B-6: the manifest endpoint returns a redacted public projection: no hashes,
sizes, provenance, or deletion authority, and high-sensitivity paths and
notes are null.
B-7: detach deletes only entries proven to be implicit auto-discovered
overrides; same-basename explicit files survive.
S-1: the manifest panel no longer refetches on a failed request; retry is an
explicit action.
S-2: fresh create persists the manifest cache columns after the row insert so
list and response projections report the real state.
S-3: git-sources.mdx matches the corrected detach, submodule, and dynamic-path
behavior.
* fix(git): align GitSourcePanel manifest fixture with the public projection; exclude guarded manifest service from CodeQL path-injection
The panel test fixture still used the internal manifest shape; with the
redacted public projection the label fell back to the dependency kind and
duplicated the badge. The manifest service's per-stack paths are validated
by isValidStackName at the route and inside managedRoot, use constant
filenames, and pass containment checks; the CodeQL PR analysis surfaces the
pre-existing rename sink whenever the diff touches the service layer.
* fix(git): restore ComposeService.ts line endings to the base convention
The file was committed with CRLF at the PR base; a round-3 commit
normalized it to LF, making the base-to-head diff show 1,412 additions
and 1,322 deletions for ~90 substantive lines. Restoring CRLF collapses
the diff to the functional changes only.
* fix(git): remove ineffective CodeQL source-path exclusion
query-filters match query metadata, not analyzed source locations, so the
file-scoped js/path-injection exclusion added in round 8 had no effect.
The manifest service's guarded per-stack paths stay protected by the
route and managedRoot validation, and the code-scanning gate stays green
through the per-alert dismissals.
* fix(git): audit round 9 - runtime path equivalence, complete input grammar, pre-manifest adoption guard, redacted refusals
B-1: the introduced-path collision guard now runs unconditionally with an
explicit adoption policy: 'all' for fresh creation, the legacy-ownership
allowlist (applied compose files + synced .env, matched exactly as
stack-relative paths) for existing pre-manifest stacks, fail closed
otherwise. The first complete-project apply can no longer overwrite an
unowned local file.
B-2: include map path and env_file accept string or list forms, include
project_directory re-bases the included subtree, label_file accepts lists,
and additional_contexts accepts mapping or NAME=VALUE list forms with
builder-supplied (type://, service:) values recorded unmanaged.
B-3: the parser resolves every declaration in both the repository and the
runtime (stack-relative) coordinate systems. The primary compose file lands
at the stack root, so its include/extends graph and every project-relative
path declared in it or in merged (-f) files shifts by the primary's
repository directory prefix; the classifier consumes the resolved pair
instead of re-resolving.
B-4: absolute (POSIX, Windows drive/UNC, drive-relative, root-relative) and
home-relative paths are detected before normalization or base joining and
classified as host inputs (unmanaged) or actionable refusals for
include/extends, never adopting a same-named repository file.
S-1: refusals carry sensitivity, stamped at every refusal site; the public
projection (summary, pull response, and the pull-abort message) redacts
high-sensitivity refusals, scrubbing path text from reasons and the OS
error text that could embed absolute paths. Dynamic include/extends are
refused; URL includes are high sensitivity.
S-3: ComposeService.ts line endings restored (separate commit).
S-2: invalid CodeQL source-path filter removed (separate commit).
* chore: bump nanoid to 3.3.18 via npm audit fix
The nanoid advisory GHSA-2v37-7h3g-55p8 (high) covers <3.3.17 and was
published after the last green CI run; both lockfiles pinned 3.3.16.
npm audit fix bumps the transitive dependency to 3.3.18.
* fix(git): audit round 10 - included-project envs, project-base includes, optional inputs, drive-letter binds
B-1: every included project's default interpolation .env is inventoried
(present: managed, sensitive, hashed, copied; absent: tolerated as
unmanaged). interpolation: false and same-base includes skip the entry.
B-2: include, include-env, and extends.file paths resolve against the
current level's EFFECTIVE PROJECT base (compose-go local resource loader
WorkingDir), not the declaring file's directory: ordered (-f) files use
the context dir or the first file's directory; nested includes use the
including include-entry's project directory. Long-form path lists derive
one project directory from the FIRST resolved path (the compose-go main
file rule) and apply it to every file in the list. Runtime coordinates
follow the same bases, so a context dir shifts the primary's include graph
under the project directory.
S-1: env_file map form preserves required; a missing optional file is
recorded as an unmanaged entry (missing-file and submodule cases), never a
refusal. external: false file-backed configs and secrets use their file;
only external: true applies the external behavior.
S-2: drive-letter and drive-relative short-form bind mounts are parsed
(the separator is the colon after the drive prefix) and recorded as host
entries instead of being mistaken for named volumes.
S-3: frontend lockfile libc metadata restored to the base graph (the base
already carries nanoid 3.3.18).
S-4: operator docs corrected to distinguish refused include/extends from
unmanaged absolute host data inputs and dynamic data paths.
* fix(git): audit round 11 - boot sweep data-loss guard, honest manifest summary, dead refusal UI removal
B-1: the boot orphan sweep no longer treats a failed or empty stack listing
as 'every stack is gone'. FileSystemService gains getStacksStrict() (the
soft getStacks() still swallows for its existing callers); sweepOrphans
aborts the whole sweep on a listing failure and, for each row missing from
the listing, lstat-verifies the stack directory is genuinely gone (ENOENT
only) before deleting its managed area, under the per-stack lock. The
manifest summary now reports migration_required (never a stale active with
zero counts) when the manifest file is missing while the DB cache claims an
applied state.
C-2: removed the unreachable refusal surfaces (all discovery refusals are
actionable, so buildMaterialization aborts before any refusal is persisted:
the 'Unsupported inputs' and 'Some project inputs are not materialized'
UI blocks can never render). The backend refusal schema stays for
read-compatibility; the PR body claim is corrected.
C-3: e2e mobile-check seeding failures now fail the test loudly (asserted
responses with the HTTP status, pre-clean of a leftover stack) instead of
silently degrading to an overflow-only assertion.
* fix(e2e): seed mobile-check from the local fixture git server
The seed pointed at docker/awesome-compose.git with compose_paths
['compose.yaml'], but that repository has no root compose.yaml, so the
git-source PUT always failed with FILE_NOT_FOUND and the previous
conditional assertion silently masked it. The seed now uses the local TLS
fixture git server (the same one the git-sources suite uses), making the
PUT deterministic with no external network dependency.
* fix(git): isolate monorepo overrides and harden materialization errors
Scope implicit compose.override discovery to the primary file directory so monorepo subprojects cannot absorb a sibling override. Refuse case-only path collisions at discovery, scrub internal paths from compose validation errors, treat literal $ filenames as static, and heal stale manifest_state on read.
This commit is contained in:
Anso
@@ -0,0 +1,639 @@
|
||||
/**
|
||||
* Pure Compose input declaration parser for the Git managed-project
|
||||
* materializer. Walks compose YAML (explicit files plus recursive include /
|
||||
* extends.file graphs) and emits every repository-local input that can affect
|
||||
* validation or deployment, WITHOUT touching the filesystem: file contents are
|
||||
* injected via the `read` callback so this module stays side-effect free and
|
||||
* testable.
|
||||
*
|
||||
* Every declaration is resolved in TWO coordinate systems:
|
||||
* - source: the repository path of the file (what the clone contains), and
|
||||
* - materialized: the stack-relative path the file occupies at runtime.
|
||||
* They diverge when the runtime layout relocates a file: the primary compose
|
||||
* file always lands at the stack root, so its entire include/extends graph
|
||||
* (and every project-relative path declared in it) shifts by the primary's
|
||||
* repository directory prefix. Merged (-f) files keep their own repository
|
||||
* paths, but their include/extends graph resolves against the base file's
|
||||
* directory at source and shifts to the stack root at runtime when no context
|
||||
* dir is configured; include/extends-reached files keep their own project
|
||||
* directory unless a relocation applies.
|
||||
*
|
||||
* Resolution rules (compose spec / compose-go loader):
|
||||
* - `include:`, `extends.file`, and include map-form `env_file` paths resolve
|
||||
* against the current level's EFFECTIVE PROJECT base (the compose-go local
|
||||
* resource loader's WorkingDir is the project directory): the context dir,
|
||||
* or the base file's directory for merged (-f) files at the top level; the
|
||||
* including include-entry's project directory for nested includes.
|
||||
* - An included project's interpolation env defaults to `.env` in its project
|
||||
* directory; absence is tolerated.
|
||||
* - For a long-form include path LIST, the FIRST resolved path is the
|
||||
* included project's main file and defines its directory; later paths are
|
||||
* overrides of the same project. include map-form `project_directory`
|
||||
* overrides the included project's directory.
|
||||
* - service `env_file`, top-level `configs`/`secrets` `file:`, `label_file`
|
||||
* and `build.context` resolve against the effective project directory: the
|
||||
* context dir, or the base file's directory for merged (-f) files; files
|
||||
* reached via include/extends keep their own project directory. An omitted
|
||||
* build context defaults to that project directory.
|
||||
* - Absolute (POSIX, Windows drive/UNC, drive-relative, root-relative) and
|
||||
* home-relative (`~`) paths are HOST paths: emitted with baseDir 'host' so
|
||||
* the classifier records them as unmanaged (data inputs) or refuses them
|
||||
* (include/extends), never adopting a same-named repository file.
|
||||
*
|
||||
* Never throws: parse errors are collected into `parseErrors` and surface as
|
||||
* refusals at classification time.
|
||||
*/
|
||||
import path from 'path';
|
||||
import YAML from 'yaml';
|
||||
import type {
|
||||
DeclaredInput,
|
||||
DynamicInput,
|
||||
InputDependencyKind,
|
||||
InputRole,
|
||||
ParsedDeclaredInputs,
|
||||
} from '../types/gitProjectManifest';
|
||||
|
||||
// Refuse to parse anything beyond this bound so a malformed (or adversarial)
|
||||
// compose file cannot exhaust heap while walking the project. Mirrors the cap
|
||||
// in composeDependencyParse.ts / composePreview.ts.
|
||||
const MAX_COMPOSE_PARSE_BYTES = 1_048_576; // 1 MiB
|
||||
|
||||
// Include/extends recursion bound; deeper graphs are refused as unsupported.
|
||||
const MAX_INCLUDE_DEPTH = 16;
|
||||
|
||||
export interface ParseOptions {
|
||||
/** Repo-relative project root (today's context_dir); null = repo root. */
|
||||
projectRoot: string | null;
|
||||
/** Fetches a repo-relative file's content for include/extends recursion; null when unreadable. */
|
||||
read: (repoPath: string) => string | null;
|
||||
}
|
||||
|
||||
interface ComposeRefs {
|
||||
inputs: DeclaredInput[];
|
||||
dynamic: DynamicInput[];
|
||||
parseErrors: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Walk context for one compose file: its repository path, its runtime
|
||||
* (materialized) path ('' = stack root), and the project bases used to
|
||||
* resolve project-relative declarations in both coordinate systems.
|
||||
*/
|
||||
interface FileContext {
|
||||
repoPath: string;
|
||||
runtimePath: string;
|
||||
projectBase: string | null;
|
||||
runtimeProjectBase: string | null;
|
||||
}
|
||||
|
||||
/** True when the path contains a Compose `$VAR` / `${VAR}` interpolation form. */
|
||||
export function isDynamicPath(p: string): boolean {
|
||||
return /\$\{[^}]*\}|\$[A-Za-z_][A-Za-z0-9_]*/.test(p);
|
||||
}
|
||||
|
||||
/** Absolute (POSIX, Windows drive/UNC, drive-relative, root-relative) or home-relative host path. */
|
||||
export function isHostAbsolutePath(p: string): boolean {
|
||||
return p.startsWith('/') || p.startsWith('~') || /^[A-Za-z]:/.test(p) || p.startsWith('\\');
|
||||
}
|
||||
|
||||
export function isUrl(p: string): boolean {
|
||||
return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(p);
|
||||
}
|
||||
|
||||
function dirOf(p: string): string | null {
|
||||
return p && p.includes('/') ? p.slice(0, p.lastIndexOf('/')) : null;
|
||||
}
|
||||
|
||||
/** Normalize a resolved path; null when it escapes its base (.. / absolute). */
|
||||
function normalizeWithinBase(candidate: string): string | null {
|
||||
// Backslashes are normalized BEFORE collapse so `sub\..\x` (Windows-style
|
||||
// separators) collapses and escapes are detected, never emitted raw.
|
||||
const normalized = path.posix.normalize(candidate.replace(/\\/g, '/')).replace(/^\.\//, '');
|
||||
if (normalized === '..' || normalized.startsWith('../') || path.posix.isAbsolute(normalized)) return null;
|
||||
return normalized;
|
||||
}
|
||||
|
||||
/** Resolve a path against a base; null when the result escapes the base. */
|
||||
function resolveWithinBase(base: string | null, target: string): string | null {
|
||||
return normalizeWithinBase(base ? `${base}/${target}` : target);
|
||||
}
|
||||
|
||||
function emitInput(
|
||||
refs: ComposeRefs,
|
||||
rawPath: string | null,
|
||||
sourcePath: string | null,
|
||||
materializedPath: string | null,
|
||||
kind: InputDependencyKind,
|
||||
role: InputRole,
|
||||
fromFile: string,
|
||||
baseDir: DeclaredInput['baseDir'],
|
||||
service: string | null = null,
|
||||
required = true,
|
||||
): void {
|
||||
if (rawPath !== null && isDynamicPath(rawPath)) {
|
||||
refs.dynamic.push({ sourcePath: rawPath, kind, note: 'Path contains a variable; resolved by Compose at deploy time, not enumerated.' });
|
||||
return;
|
||||
}
|
||||
refs.inputs.push({ sourcePath, materializedPath, baseDir, kind, role, fromFile, service, required });
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a project-relative declaration resolved in both coordinate systems.
|
||||
* Host/absolute paths and paths that escape either base are emitted as host
|
||||
* inputs (the classifier records them unmanaged or refuses include/extends).
|
||||
*/
|
||||
function emitProjectRelative(
|
||||
refs: ComposeRefs,
|
||||
raw: string,
|
||||
kind: InputDependencyKind,
|
||||
role: InputRole,
|
||||
fromFile: string,
|
||||
ctx: FileContext,
|
||||
baseDir: DeclaredInput['baseDir'],
|
||||
service: string | null = null,
|
||||
required = true,
|
||||
): void {
|
||||
if (isHostAbsolutePath(raw)) {
|
||||
emitInput(refs, raw, raw, null, kind, role, fromFile, 'host', service, required);
|
||||
return;
|
||||
}
|
||||
const source = resolveWithinBase(ctx.projectBase, raw);
|
||||
const materialized = resolveWithinBase(ctx.runtimeProjectBase, raw);
|
||||
if (source === null || materialized === null) {
|
||||
emitInput(refs, raw, raw, null, kind, role, fromFile, 'host', service, required);
|
||||
return;
|
||||
}
|
||||
emitInput(refs, raw, source, materialized, kind, role, fromFile, baseDir, service, required);
|
||||
}
|
||||
|
||||
function asString(value: unknown): string | undefined {
|
||||
if (typeof value === 'string') return value;
|
||||
if (typeof value === 'number') return String(value);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/** Normalize a string-or-list-of-strings value into its string items. */
|
||||
function asStringList(value: unknown): string[] {
|
||||
if (typeof value === 'string') return [value];
|
||||
if (typeof value === 'number') return [String(value)];
|
||||
if (Array.isArray(value)) {
|
||||
return value.map(asString).filter((p): p is string => p !== undefined);
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
/** Normalize an env_file entry (string, list item, or map {path, required}) to its path and optionality. */
|
||||
function envFilePath(value: unknown): { path: string; required: boolean } | undefined {
|
||||
if (typeof value === 'string') return { path: value, required: true };
|
||||
if (value && typeof value === 'object' && !Array.isArray(value)) {
|
||||
const p = (value as Record<string, unknown>).path;
|
||||
const path = asString(p);
|
||||
if (path === undefined) return undefined;
|
||||
const required = (value as Record<string, unknown>).required;
|
||||
return { path, required: required !== false };
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
||||
/** Normalize a configs/secrets entry to a file path, or null for external/env forms. */
|
||||
function resourceFilePath(value: unknown): string | null {
|
||||
if (value && typeof value === 'object' && !Array.isArray(value)) {
|
||||
const record = value as Record<string, unknown>;
|
||||
if (record.external === true) return null; // docker supplies it; only an explicit true applies
|
||||
if ('env' in record || 'environment' in record) return null; // env-injected
|
||||
const f = record.file;
|
||||
if (f !== undefined) return asString(f) ?? null;
|
||||
return null; // plain {} or name-only reference
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function shortFormBindSource(volume: string): string | null {
|
||||
// A drive-letter prefix (C:\ or C:) keeps its colon as part of the
|
||||
// source; the source/target separator is the NEXT colon. UNC sources
|
||||
// (\\server\share) have no colon and split at the separator as usual.
|
||||
const separator = /^[A-Za-z]:/.test(volume) ? volume.indexOf(':', 2) : volume.indexOf(':');
|
||||
if (separator === -1) return null;
|
||||
const src = volume.slice(0, separator);
|
||||
// Named volumes have no path separators or leading dot/slash/tilde.
|
||||
if (/^[A-Za-z0-9_.-]+$/.test(src) && !src.startsWith('.') && !src.startsWith('~')) return null;
|
||||
return src;
|
||||
}
|
||||
|
||||
/** Collect bind-mount host sources from a service volumes list. */
|
||||
function collectBindMounts(volumes: unknown, fromFile: string, refs: ComposeRefs, ctx: FileContext): void {
|
||||
const emitBindSource = (src: string): void => {
|
||||
if (isHostAbsolutePath(src)) {
|
||||
emitInput(refs, src, null, null, 'bind-mount', 'bind-mount', fromFile, 'host');
|
||||
} else {
|
||||
emitProjectRelative(refs, src, 'bind-mount', 'bind-mount', fromFile, ctx, 'project-root');
|
||||
}
|
||||
};
|
||||
if (!Array.isArray(volumes)) return;
|
||||
for (const entry of volumes) {
|
||||
if (typeof entry === 'string') {
|
||||
const src = shortFormBindSource(entry);
|
||||
if (src !== null) emitBindSource(src);
|
||||
continue;
|
||||
}
|
||||
if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
|
||||
const record = entry as Record<string, unknown>;
|
||||
if (record.type === 'bind' && typeof record.source === 'string') {
|
||||
emitBindSource(record.source);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Collect build declarations (context, dockerfile, secrets, additional contexts). */
|
||||
function collectBuild(build: unknown, fromFile: string, refs: ComposeRefs, ctx: FileContext, service: string | null): void {
|
||||
if (typeof build === 'string') {
|
||||
emitProjectRelative(refs, build, 'build-context', 'build-context', fromFile, ctx, 'compose-file-dir', service);
|
||||
return;
|
||||
}
|
||||
if (!build || typeof build !== 'object' || Array.isArray(build)) return;
|
||||
const record = build as Record<string, unknown>;
|
||||
if (typeof record.context === 'string') {
|
||||
emitProjectRelative(refs, record.context, 'build-context', 'build-context', fromFile, ctx, 'compose-file-dir', service);
|
||||
} else {
|
||||
// An omitted context defaults to the declaring file's project
|
||||
// directory (compose spec); resolved by emitProjectRelative.
|
||||
emitProjectRelative(refs, '.', 'build-context', 'build-context', fromFile, ctx, 'compose-file-dir', service);
|
||||
}
|
||||
if (typeof record.dockerfile === 'string') {
|
||||
if (isHostAbsolutePath(record.dockerfile)) {
|
||||
emitInput(refs, record.dockerfile, record.dockerfile, null, 'dockerfile', 'dockerfile', fromFile, 'host', service);
|
||||
} else {
|
||||
// Dockerfile is relative to the context; the classifier rebases it.
|
||||
emitInput(refs, record.dockerfile, record.dockerfile, null, 'dockerfile', 'dockerfile', fromFile, 'compose-file-dir', service);
|
||||
}
|
||||
}
|
||||
if (record.secrets && Array.isArray(record.secrets)) {
|
||||
// Long syntax carries only source/target/uid/gid/mode; `source` names
|
||||
// a TOP-LEVEL SECRET (compose errors if it is not defined in the
|
||||
// top-level secrets section), never a file path. The referenced
|
||||
// secret's file, when file-backed, is emitted by the top-level
|
||||
// secrets walk; the reference itself is recorded as unmanaged, the
|
||||
// same as the string form.
|
||||
record.secrets.forEach(() => {
|
||||
emitInput(refs, null, null, null, 'build-secret', 'build-secret', fromFile, 'host', service);
|
||||
});
|
||||
}
|
||||
// additional_contexts: mapping (name -> value) or list of NAME=VALUE
|
||||
// strings (compose build spec). Path values are project-relative inputs;
|
||||
// type:// and service: values are supplied by the image builder at build
|
||||
// time and recorded unmanaged.
|
||||
let additional: Array<[string, unknown]> = [];
|
||||
if (record.additional_contexts && typeof record.additional_contexts === 'object' && !Array.isArray(record.additional_contexts)) {
|
||||
additional = Object.entries(record.additional_contexts as Record<string, unknown>);
|
||||
} else if (Array.isArray(record.additional_contexts)) {
|
||||
for (const item of record.additional_contexts) {
|
||||
const text = asString(item);
|
||||
if (text !== undefined) {
|
||||
const eq = text.indexOf('=');
|
||||
if (eq > 0) additional.push([text.slice(0, eq), text.slice(eq + 1)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const [, value] of additional) {
|
||||
const p = asString(value);
|
||||
if (p === undefined) continue;
|
||||
if (isUrl(p) || p.startsWith('service:')) {
|
||||
emitInput(refs, p, p, null, 'build-additional-context', 'build-additional-context', fromFile, 'host', service);
|
||||
} else {
|
||||
emitProjectRelative(refs, p, 'build-additional-context', 'build-additional-context', fromFile, ctx, 'compose-file-dir', service);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Walk one service definition for file-backed inputs. */
|
||||
function walkService(serviceName: string, service: unknown, fromFile: string, refs: ComposeRefs, ctx: FileContext): void {
|
||||
if (!service || typeof service !== 'object' || Array.isArray(service)) return;
|
||||
const record = service as Record<string, unknown>;
|
||||
|
||||
// extends.file (map form) is emitted and recursed by parseFileInner, which
|
||||
// needs the resolved target for the recursion; the string form extends a
|
||||
// sibling service in the same file.
|
||||
|
||||
const envFile = record.env_file;
|
||||
if (envFile !== undefined) {
|
||||
const entries = Array.isArray(envFile) ? envFile : [envFile];
|
||||
for (const entry of entries) {
|
||||
const p = envFilePath(entry);
|
||||
if (p !== undefined) {
|
||||
emitProjectRelative(refs, p.path, 'env_file', 'env', fromFile, ctx, 'compose-file-dir', null, p.required);
|
||||
} else {
|
||||
refs.parseErrors.push(`env_file entry in ${fromFile} has no resolvable path`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const labelFile of asStringList(record.label_file)) {
|
||||
emitProjectRelative(refs, labelFile, 'label_file', 'label-file', fromFile, ctx, 'compose-file-dir');
|
||||
}
|
||||
|
||||
if (record.build !== undefined) collectBuild(record.build, fromFile, refs, ctx, serviceName);
|
||||
collectBindMounts(record.volumes, fromFile, refs, ctx);
|
||||
|
||||
// Per-service configs/secrets references are keys into the top-level
|
||||
// maps, which the top-level walk emits; nothing to record here.
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a file-relative declaration (include/extends/include-env), returning
|
||||
* the resolved source/materialized pair; the caller recurses via
|
||||
* readAndRecurse when the target is a repository file.
|
||||
*/
|
||||
function emitFileRelative(
|
||||
refs: ComposeRefs,
|
||||
raw: string,
|
||||
kind: InputDependencyKind,
|
||||
role: InputRole,
|
||||
fromFile: string,
|
||||
ctx: FileContext,
|
||||
baseDir: DeclaredInput['baseDir'] = 'repo-root',
|
||||
): { source: string | null; materialized: string | null } {
|
||||
if (isHostAbsolutePath(raw)) {
|
||||
emitInput(refs, raw, raw, null, kind, role, fromFile, 'host');
|
||||
return { source: null, materialized: null };
|
||||
}
|
||||
if (isUrl(raw)) {
|
||||
emitInput(refs, raw, raw.trim(), null, kind, role, fromFile, baseDir);
|
||||
return { source: null, materialized: null };
|
||||
}
|
||||
// Include, include-env, and extends paths resolve against the current
|
||||
// level's EFFECTIVE PROJECT base (compose-go: the local resource
|
||||
// loader's WorkingDir is the project directory), not the declaring
|
||||
// file's own directory.
|
||||
const source = resolveWithinBase(ctx.projectBase, raw);
|
||||
const materialized = resolveWithinBase(ctx.runtimeProjectBase, raw);
|
||||
if (source === null || materialized === null) {
|
||||
emitInput(refs, raw, raw, null, kind, role, fromFile, 'host');
|
||||
return { source: null, materialized: null };
|
||||
}
|
||||
emitInput(refs, raw, source, materialized, kind, role, fromFile, baseDir);
|
||||
return { source, materialized };
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse one compose file into declarations, recursing into include/extends.
|
||||
* Cycle detection uses the RECURSION STACK (a file re-entered while still
|
||||
* being walked is a real cycle); a file reached again after completion is a
|
||||
* shared base (diamond / repeated include) and dedupes silently.
|
||||
*/
|
||||
function parseFile(
|
||||
ctx: FileContext,
|
||||
content: string,
|
||||
opts: ParseOptions,
|
||||
refs: ComposeRefs,
|
||||
visited: Set<string>,
|
||||
stack: Set<string>,
|
||||
depth: number,
|
||||
): void {
|
||||
const normalized = normalizeRepoPath(ctx.repoPath);
|
||||
if (stack.has(normalized)) {
|
||||
refs.parseErrors.push(`Include/extends cycle detected at ${normalized}`);
|
||||
return;
|
||||
}
|
||||
if (visited.has(normalized)) {
|
||||
return; // shared base file, not a cycle
|
||||
}
|
||||
stack.add(normalized);
|
||||
try {
|
||||
parseFileInner(ctx, content, opts, refs, visited, stack, depth);
|
||||
} finally {
|
||||
stack.delete(normalized);
|
||||
visited.add(normalized);
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeRepoPath(p: string): string {
|
||||
return path.posix.normalize(p.replace(/\\/g, '/')).replace(/^\/+/, '');
|
||||
}
|
||||
|
||||
function parseFileInner(
|
||||
ctx: FileContext,
|
||||
content: string,
|
||||
opts: ParseOptions,
|
||||
refs: ComposeRefs,
|
||||
visited: Set<string>,
|
||||
stack: Set<string>,
|
||||
depth: number,
|
||||
): void {
|
||||
const normalized = normalizeRepoPath(ctx.repoPath);
|
||||
if (depth > MAX_INCLUDE_DEPTH) {
|
||||
refs.parseErrors.push(`Include/extends graph exceeds depth ${MAX_INCLUDE_DEPTH} at ${normalized}`);
|
||||
return;
|
||||
}
|
||||
if (content.length > MAX_COMPOSE_PARSE_BYTES) {
|
||||
refs.parseErrors.push(`Compose file ${normalized} exceeds the ${MAX_COMPOSE_PARSE_BYTES}-byte parse cap`);
|
||||
return;
|
||||
}
|
||||
|
||||
let doc: unknown;
|
||||
try {
|
||||
doc = YAML.parse(content);
|
||||
} catch (e) {
|
||||
refs.parseErrors.push(`Cannot parse compose file ${normalized}: ${e instanceof Error ? e.message : String(e)}`);
|
||||
return;
|
||||
}
|
||||
if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return;
|
||||
|
||||
const root = doc as Record<string, unknown>;
|
||||
|
||||
// Top-level include: list of paths or maps {path, env_file, project_directory}.
|
||||
const include = root.include;
|
||||
if (include !== undefined) {
|
||||
const items = Array.isArray(include) ? include : [include];
|
||||
for (const item of items) {
|
||||
if (typeof item === 'string') {
|
||||
processIncludeEntry(refs, [item], undefined, normalized, ctx, opts, visited, stack, depth);
|
||||
} else if (item && typeof item === 'object' && !Array.isArray(item)) {
|
||||
const map = item as Record<string, unknown>;
|
||||
// path accepts a string or a list of strings (merged in order).
|
||||
const paths = asStringList(map.path);
|
||||
if (paths.length === 0) {
|
||||
refs.parseErrors.push(`Include entry in ${normalized} has no resolvable path`);
|
||||
continue;
|
||||
}
|
||||
processIncludeEntry(refs, paths, map, normalized, ctx, opts, visited, stack, depth);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Per-file service walk (keeps declaring-file provenance for relative refs).
|
||||
if (root.services && typeof root.services === 'object' && !Array.isArray(root.services)) {
|
||||
for (const [serviceName, service] of Object.entries(root.services as Record<string, unknown>)) {
|
||||
walkService(serviceName, service, normalized, refs, ctx);
|
||||
// extends.file recursion after recording the declaration.
|
||||
if (service && typeof service === 'object' && !Array.isArray(service)) {
|
||||
const ext = (service as Record<string, unknown>).extends;
|
||||
if (ext && typeof ext === 'object' && !Array.isArray(ext)) {
|
||||
const fileTarget = asString((ext as Record<string, unknown>).file);
|
||||
if (fileTarget !== undefined) {
|
||||
const resolved = emitFileRelative(refs, fileTarget, 'extends', 'compose-additional', normalized, ctx);
|
||||
readAndRecurse(resolved, ctx, opts, refs, visited, stack, depth, 'extends.file target');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Top-level configs / secrets file forms.
|
||||
for (const [key, kind, role] of [
|
||||
['configs', 'config', 'config'],
|
||||
['secrets', 'secret', 'secret'],
|
||||
] as const) {
|
||||
const resources = root[key];
|
||||
if (!resources || typeof resources !== 'object' || Array.isArray(resources)) continue;
|
||||
for (const def of Object.values(resources as Record<string, unknown>)) {
|
||||
const file = resourceFilePath(def);
|
||||
if (file !== null) {
|
||||
emitProjectRelative(refs, file, kind, role, normalized, ctx, 'compose-file-dir');
|
||||
} else if (def !== null && def !== undefined) {
|
||||
// external / env / name-only forms are docker-supplied or
|
||||
// unresolvable; record an unmanaged placeholder.
|
||||
emitInput(refs, null, null, null, kind, role, normalized, 'host');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Process one include entry (string path, or map with a path list): resolve
|
||||
* each path against the current level's project base, derive the included
|
||||
* project's bases (project_directory, or the FIRST resolved path's directory
|
||||
* per the compose-go "main file" rule), emit the included project's default
|
||||
* interpolation .env, and recurse.
|
||||
*/
|
||||
function processIncludeEntry(
|
||||
refs: ComposeRefs,
|
||||
paths: string[],
|
||||
map: Record<string, unknown> | undefined,
|
||||
fromFile: string,
|
||||
ctx: FileContext,
|
||||
opts: ParseOptions,
|
||||
visited: Set<string>,
|
||||
stack: Set<string>,
|
||||
depth: number,
|
||||
): void {
|
||||
const resolvedPaths = paths.map((p) => emitFileRelative(refs, p, 'include', 'compose-additional', fromFile, ctx));
|
||||
const first = resolvedPaths[0];
|
||||
// interpolation: false disables interpolation for the included project,
|
||||
// so its default .env is never probed.
|
||||
const interpolate = map?.interpolation !== false;
|
||||
const projectDir = asString(map?.project_directory);
|
||||
let childProjectBase: string | null;
|
||||
let childRuntimeProjectBase: string | null;
|
||||
if (projectDir !== undefined) {
|
||||
childProjectBase = resolveWithinBase(ctx.projectBase, projectDir);
|
||||
childRuntimeProjectBase = resolveWithinBase(ctx.runtimeProjectBase, projectDir);
|
||||
if (childProjectBase === null || childRuntimeProjectBase === null) {
|
||||
refs.parseErrors.push(`Include project_directory ${projectDir} in ${fromFile} escapes its base`);
|
||||
return;
|
||||
}
|
||||
} else if (first !== undefined && first.source !== null && first.materialized !== null) {
|
||||
// Without project_directory, the FIRST resolved path is the included
|
||||
// project's main file and defines its directory; later paths are
|
||||
// overrides of the same project.
|
||||
childProjectBase = dirOf(first.source);
|
||||
childRuntimeProjectBase = dirOf(first.materialized);
|
||||
} else {
|
||||
return; // host/URL/escape: emitted, the classifier decides
|
||||
}
|
||||
|
||||
// The included project's interpolation env defaults to .env in its
|
||||
// project directory (compose include spec); absence is tolerated.
|
||||
// interpolation: false disables it (handled above). When the included
|
||||
// project's bases equal the parent's (a same-directory include), the
|
||||
// entry would duplicate the parent's interpolation env, so it is skipped.
|
||||
if (interpolate && !(childProjectBase === ctx.projectBase && childRuntimeProjectBase === ctx.runtimeProjectBase)) {
|
||||
emitInput(refs, '.env', resolveWithinBase(childProjectBase, '.env')!, resolveWithinBase(childRuntimeProjectBase, '.env')!, 'interpolation-env', 'env', fromFile, 'repo-root');
|
||||
}
|
||||
|
||||
const childOverride = { projectBase: childProjectBase, runtimeProjectBase: childRuntimeProjectBase };
|
||||
for (const resolved of resolvedPaths) {
|
||||
readAndRecurse(resolved, ctx, opts, refs, visited, stack, depth, 'Included compose file', childOverride);
|
||||
}
|
||||
|
||||
// Explicit env_file accepts a string or a list of strings; resolves
|
||||
// against the current level's project base (compose-go include env).
|
||||
for (const env of asStringList(map?.env_file)) {
|
||||
emitFileRelative(refs, env, 'include-env', 'env', fromFile, ctx);
|
||||
}
|
||||
}
|
||||
|
||||
/** Read a resolved include/extends target and recurse when it is a repository file. */
|
||||
function readAndRecurse(
|
||||
resolved: { source: string | null; materialized: string | null },
|
||||
ctx: FileContext,
|
||||
opts: ParseOptions,
|
||||
refs: ComposeRefs,
|
||||
visited: Set<string>,
|
||||
stack: Set<string>,
|
||||
depth: number,
|
||||
errorLabel: string,
|
||||
childOverride?: { projectBase: string | null; runtimeProjectBase: string | null },
|
||||
): void {
|
||||
// Host/URL/escape paths emit with both sides null; the classifier decides.
|
||||
if (resolved.source === null || resolved.materialized === null) return;
|
||||
const nested = opts.read(resolved.source);
|
||||
if (nested === null) {
|
||||
refs.parseErrors.push(`${errorLabel} ${resolved.source} is unreadable`);
|
||||
return;
|
||||
}
|
||||
parseFile(
|
||||
{
|
||||
repoPath: resolved.source,
|
||||
runtimePath: resolved.materialized,
|
||||
projectBase: childOverride?.projectBase ?? dirOf(resolved.source),
|
||||
runtimeProjectBase: childOverride?.runtimeProjectBase ?? dirOf(resolved.materialized),
|
||||
},
|
||||
nested,
|
||||
opts,
|
||||
refs,
|
||||
visited,
|
||||
stack,
|
||||
depth + 1,
|
||||
);
|
||||
}
|
||||
|
||||
export function parseDeclaredInputs(
|
||||
orderedContents: Array<{ path: string; content: string }>,
|
||||
opts: ParseOptions,
|
||||
): ParsedDeclaredInputs {
|
||||
const refs: ComposeRefs = { inputs: [], dynamic: [], parseErrors: [] };
|
||||
const visited = new Set<string>();
|
||||
const stack = new Set<string>();
|
||||
// Merged (-f) files share the TOP project's bases: the context dir, or
|
||||
// the base (first) file's directory. The primary file lands at the stack
|
||||
// root at runtime, so its runtime path is '' while additional files keep
|
||||
// their repository paths.
|
||||
const orderedProjectBase = opts.projectRoot ?? dirOf(orderedContents[0]?.path ?? '');
|
||||
const orderedRuntimeProjectBase = opts.projectRoot ?? null;
|
||||
for (const [index, file] of orderedContents.entries()) {
|
||||
parseFile(
|
||||
{
|
||||
repoPath: file.path,
|
||||
runtimePath: index === 0 ? '' : file.path,
|
||||
projectBase: orderedProjectBase,
|
||||
runtimeProjectBase: orderedRuntimeProjectBase,
|
||||
},
|
||||
file.content,
|
||||
opts,
|
||||
refs,
|
||||
visited,
|
||||
stack,
|
||||
0,
|
||||
);
|
||||
}
|
||||
|
||||
// Interpolation env at the project root (compose loads it for variable
|
||||
// substitution). Always declared; classification decides managed vs absent.
|
||||
const interpRoot = opts.projectRoot ?? '';
|
||||
const interpPath = interpRoot ? `${interpRoot}/.env` : '.env';
|
||||
emitInput(refs, interpPath, interpPath, interpPath, 'interpolation-env', 'env', '<project>', 'project-root');
|
||||
|
||||
return { inputs: refs.inputs, dynamic: refs.dynamic, parseErrors: refs.parseErrors };
|
||||
}
|
||||
Reference in New Issue
Block a user