@wpmoo/odoo 0.8.58 → 0.8.60

package/dist/source-manifest.js

@@ -0,0 +1,338 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isValidPathSegment, validateRepoPath } from './path-validation.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+export const sourceManifestPath = 'odoo/custom/manifests/sources.yaml';
+function fail(message) {
+    throw new Error(`Invalid source manifest ${sourceManifestPath}: ${message}`);
+}
+export function normalizeSourceType(value) {
+    return validSourceTypes.includes(value) ? value : 'private';
+}
+function dedupeAndSort(entries) {
+    const uniqueByTypePath = new Map();
+    for (const entry of entries) {
+        uniqueByTypePath.set(`${entry.type}:${entry.path}`, entry);
+    }
+    return [...uniqueByTypePath.values()].sort((left, right) => {
+        const typeOrder = left.type.localeCompare(right.type);
+        if (typeOrder !== 0)
+            return typeOrder;
+        return left.path.localeCompare(right.path);
+    });
+}
+function stripInlineComment(raw) {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let index = 0; index < raw.length; index += 1) {
+        const char = raw[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === "'" && !inDouble) {
+            inSingle = !inSingle;
+        }
+        else if (char === '"' && !inSingle) {
+            inDouble = !inDouble;
+        }
+        else if (char === '#' && !inSingle && !inDouble) {
+            return raw.slice(0, index).trimEnd();
+        }
+    }
+    return raw;
+}
+function parseScalar(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return JSON.parse(trimmed);
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1).replace(/\\'/g, "'");
+    }
+    return trimmed;
+}
+function leadingSpaces(line) {
+    return line.length - line.trimStart().length;
+}
+function parseSourcesBlock(content) {
+    const lines = content.split(/\r?\n/).map((line, index) => ({
+        lineNumber: index + 1,
+        line: line.replace(/\t/g, '  '),
+        trimmedLine: line.replace(/\t/g, '  ').trim(),
+    }));
+    const sourcesKeywordLine = lines.find((line) => /^\s*sources\s*:\s*(?:\[[^\]]*\])?\s*$/.test(stripInlineComment(line.line)));
+    if (!sourcesKeywordLine) {
+        fail('Missing top-level sources entry.');
+    }
+    const rawSourcesValue = stripInlineComment(sourcesKeywordLine.line).replace(/^\s*sources\s*:\s*/, '');
+    if (rawSourcesValue === '[]') {
+        return { sources: [] };
+    }
+    if (rawSourcesValue && rawSourcesValue !== '') {
+        fail(`Unexpected non-list value on line ${sourcesKeywordLine.lineNumber}: sources`);
+    }
+    const sourceLines = lines.slice(sourcesKeywordLine.lineNumber);
+    const parsed = [];
+    let index = 0;
+    while (index < sourceLines.length) {
+        const headerLine = sourceLines[index];
+        const noCommentHeader = stripInlineComment(headerLine.line);
+        if (!noCommentHeader.trim()) {
+            index += 1;
+            continue;
+        }
+        const itemMatch = /^\s*-\s*type:\s*(.+)\s*$/.exec(noCommentHeader);
+        if (!itemMatch) {
+            index += 1;
+            continue;
+        }
+        const item = {
+            type: normalizeSourceType(parseScalar(itemMatch[1])),
+            path: '',
+            url: '',
+            addons: [],
+        };
+        index += 1;
+        while (index < sourceLines.length) {
+            const rawLine = sourceLines[index];
+            const noComment = stripInlineComment(rawLine.line);
+            const trimmed = noComment.trim();
+            if (!trimmed) {
+                index += 1;
+                continue;
+            }
+            if (/^\s*-\s*type:\s*/.test(noComment)) {
+                break;
+            }
+            const pathMatch = /^\s*path:\s*(.+)\s*$/.exec(noComment);
+            if (pathMatch) {
+                item.path = validateRepoPath(parseScalar(pathMatch[1]));
+                index += 1;
+                continue;
+            }
+            const urlMatch = /^\s*url:\s*(.+)\s*$/.exec(noComment);
+            if (urlMatch) {
+                item.url = parseScalar(urlMatch[1]);
+                index += 1;
+                continue;
+            }
+            const branchMatch = /^\s*branch:\s*(.+)\s*$/.exec(noComment);
+            if (branchMatch) {
+                item.branch = parseScalar(branchMatch[1]);
+                index += 1;
+                continue;
+            }
+            const addonsLine = /^\s*addons:\s*$/.exec(noComment);
+            if (addonsLine) {
+                const baseIndent = leadingSpaces(rawLine.line) + 2;
+                index += 1;
+                while (index < sourceLines.length) {
+                    const addonRaw = stripInlineComment(sourceLines[index].line);
+                    const addonTrimmed = addonRaw.trim();
+                    if (!addonTrimmed) {
+                        index += 1;
+                        continue;
+                    }
+                    const addonMatch = /^\s*-\s*(.+)\s*$/.exec(addonRaw);
+                    if (!addonMatch) {
+                        break;
+                    }
+                    if (leadingSpaces(addonRaw) < baseIndent) {
+                        break;
+                    }
+                    const addon = parseScalar(addonMatch[1]);
+                    if (addon) {
+                        item.addons.push(addon);
+                    }
+                    index += 1;
+                }
+                continue;
+            }
+            fail(`Unexpected source entry field on line ${rawLine.lineNumber}: ${trimmed}`);
+        }
+        if (!item.path) {
+            fail(`Manifest entry missing path at line ${headerLine.lineNumber}`);
+        }
+        if (!item.url) {
+            fail(`Manifest entry missing url for ${item.type}:${item.path} at line ${headerLine.lineNumber}`);
+        }
+        if (!isValidPathSegment(item.path)) {
+            fail(`Invalid manifest path at line ${headerLine.lineNumber}: ${item.path}`);
+        }
+        if (item.addons.length === 0) {
+            item.addons.push(item.path);
+        }
+        item.addons = [...new Set(item.addons.map((addon) => validateRepoPath(addon)))].sort();
+        parsed.push(item);
+    }
+    return { sources: dedupeAndSort(parsed.filter((entry) => isValidPathSegment(entry.path))) };
+}
+export async function readSourceManifest(target) {
+    try {
+        const content = await readFile(join(target, sourceManifestPath), 'utf8');
+        return parseSourcesBlock(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { sources: [] };
+        }
+        throw error;
+    }
+}
+function renderQuoted(value) {
+    return JSON.stringify(value);
+}
+export function renderSourceManifest(entries) {
+    const normalized = dedupeAndSort(entries).map((entry) => {
+        const addons = [...new Set(entry.addons.map((addon) => validateRepoPath(addon)))].sort();
+        return {
+            type: entry.type,
+            path: validateRepoPath(entry.path),
+            url: entry.url.trim(),
+            branch: entry.branch?.trim(),
+            addons: addons.length ? addons : [validateRepoPath(entry.path)],
+        };
+    });
+    if (normalized.length === 0) {
+        return 'sources: []\n';
+    }
+    const body = normalized
+        .map((entry) => {
+        const lines = [
+            `  - type: ${renderQuoted(entry.type)}`,
+            `    path: ${renderQuoted(entry.path)}`,
+            `    url: ${renderQuoted(entry.url)}`,
+        ];
+        lines.push(`    branch: ${renderQuoted(entry.branch ?? '')}`);
+        lines.push('    addons:');
+        for (const addon of entry.addons) {
+            lines.push(`      - ${renderQuoted(addon)}`);
+        }
+        return lines.join('\n');
+    })
+        .join('\n');
+    return `sources:\n${body}\n`;
+}
+export async function writeSourceManifest(target, entries) {
+    const content = renderSourceManifest(entries);
+    const path = join(target, sourceManifestPath);
+    await mkdir(join(path, '..'), { recursive: true });
+    await writeFile(path, content, 'utf8');
+}
+function entryKey(type, path) {
+    return `${type}:${path}`;
+}
+export async function upsertSourceManifestEntry(target, entry) {
+    const manifest = await readSourceManifest(target);
+    const normalized = {
+        ...entry,
+        type: normalizeSourceType(entry.type),
+        path: validateRepoPath(entry.path),
+    };
+    const next = dedupeAndSort(manifest.sources.filter((current) => entryKey(current.type, current.path) !== entryKey(normalized.type, normalized.path)));
+    next.push(normalized);
+    await writeSourceManifest(target, next);
+}
+export async function removeSourceManifestEntry(target, type, path) {
+    const manifest = await readSourceManifest(target);
+    const key = entryKey(normalizeSourceType(type), validateRepoPath(path));
+    const next = manifest.sources.filter((entry) => entryKey(entry.type, entry.path) !== key);
+    await writeSourceManifest(target, next);
+}
+export function sourceManifestEntriesFromMetadata(sourceRepos, fallbackBranch) {
+    return sourceRepos.map((repo) => ({
+        type: normalizeSourceType(repo.sourceType),
+        path: validateRepoPath(repo.path),
+        url: repo.url.trim(),
+        branch: fallbackBranch,
+        addons: repo.addons.length ? [...new Set(repo.addons.map((addon) => validateRepoPath(addon)))] : [validateRepoPath(repo.path)],
+    }));
+}
+export async function listGitmoduleSources(target) {
+    try {
+        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
+        const lines = gitmodules.split(/\r?\n/);
+        const locations = [];
+        const pathRegex = /^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/(.+)\s*$/;
+        const urlRegex = /^\s*url\s*=\s*(.+)\s*$/;
+        let pending;
+        for (const line of lines) {
+            const parsedPath = line.match(pathRegex);
+            if (parsedPath) {
+                const sourceType = parsedPath[1];
+                const repoPath = parsedPath[2]?.trim() ?? '';
+                if (!repoPath || !isValidPathSegment(repoPath)) {
+                    pending = undefined;
+                    continue;
+                }
+                pending = {
+                    type: sourceType,
+                    path: validateRepoPath(repoPath),
+                    url: '',
+                };
+                continue;
+            }
+            const parsedUrl = line.match(urlRegex);
+            if (!parsedUrl || !pending) {
+                continue;
+            }
+            const url = parseScalar(parsedUrl[1]);
+            if (url) {
+                locations.push({ ...pending, url });
+            }
+            pending = undefined;
+        }
+        return locations;
+    }
+    catch {
+        return [];
+    }
+}
+export function syncManifestFromMetadataAndGitmodules(sourceRepos, fallbackBranch, gitmodules = []) {
+    const byGitmodule = new Map();
+    for (const location of gitmodules) {
+        byGitmodule.set(`${normalizeSourceType(location.type)}:${location.path}`, location);
+    }
+    const entries = [];
+    for (const repo of sourceRepos) {
+        const normalized = {
+            type: normalizeSourceType(repo.sourceType),
+            path: validateRepoPath(repo.path),
+            url: repo.url.trim() || byGitmodule.get(`${normalizeSourceType(repo.sourceType)}:${repo.path}`)?.url || '',
+            branch: fallbackBranch,
+            addons: repo.addons.map(validateRepoPath),
+        };
+        entries.push(normalized);
+    }
+    for (const location of gitmodules) {
+        const key = `${location.type}:${location.path}`;
+        if (entries.some((entry) => `${entry.type}:${entry.path}` === key)) {
+            continue;
+        }
+        entries.push({
+            type: location.type,
+            path: location.path,
+            url: location.url,
+            branch: fallbackBranch,
+            addons: [location.path],
+        });
+    }
+    return dedupeAndSort(entries);
+}
+export function sourceReposFromManifest(entries) {
+    const normalized = dedupeAndSort(entries);
+    return normalized.map((entry) => ({
+        sourceType: entry.type,
+        path: validateRepoPath(entry.path),
+        url: entry.url,
+        addons: entry.addons.length ? [...new Set(entry.addons.map((addon) => validateRepoPath(addon)))] : [validateRepoPath(entry.path)],
+    }));
+}

package/dist/templates.js

@@ -20,6 +20,12 @@ function allAddons(options) {
 function hasSourceRepos(options) {
     return options.sourceRepos.length > 0;
 }
+function sourceTypeOf(repo) {
+    return repo.sourceType ?? 'private';
+}
+function sourceRepoRelativePath(repo) {
+    return `odoo/custom/src/${sourceTypeOf(repo)}/${repo.path}`;
+}
 function repositoryLayout(options) {
     const sourceRepoRows = hasSourceRepos(options)
         ? options.sourceRepos
@@ -91,11 +97,14 @@ ${repo.url}
 Submodule path:
 
 \`\`\`text
-odoo/custom/src/private/${repo.path}
+${sourceRepoRelativePath(repo)}
 \`\`\`
 
-Note: If this repository is an OCA or third-party source, place it under
-\`odoo/custom/src/oca\` or \`odoo/custom/src/external\` according to your policy.
+Source manifest entry:
+
+\`\`\`text
+odoo/custom/manifests/sources.yaml
+\`\`\`
 
 Expected addon layout:
 
@@ -542,7 +551,7 @@ export function renderAddonsYaml(options) {
 # Source repos are managed as Git submodules under odoo/custom/src/private.
 # Do not duplicate these same repos in repos.yaml.
 
-${options.sourceRepos.map((repo) => `private/${repo.path}:\n${yamlList(repo.addons)}`).join('\n\n')}
+${options.sourceRepos.map((repo) => `${sourceTypeOf(repo)}/${repo.path}:\n${yamlList(repo.addons)}`).join('\n\n')}
 `;
 }
 export function renderReposYaml(options) {
@@ -551,7 +560,7 @@ export function renderReposYaml(options) {
 # Project source repositories are intentionally not listed here because
 # they are pinned as Git submodules:
 #
-${options.sourceRepos.map((repo) => `# - private/${repo.path}`).join('\n')}
+${options.sourceRepos.map((repo) => `# - ${sourceTypeOf(repo)}/${repo.path}`).join('\n')}
 #
 # Keep this file for upstream/OCA repositories that should be aggregated.
 
@@ -628,7 +637,7 @@ export function renderAgents(options) {
 source directory below for this environment:
 
 \`\`\`text
-${options.sourceRepos.map((repo) => `odoo/custom/src/private/${repo.path}`).join('\n')}
+${options.sourceRepos.map(sourceRepoRelativePath).join('\n')}
 \`\`\`
 
 ${repoDuplicationNote()}`

package/docs/generated-environment-verification.md

@@ -21,9 +21,11 @@ not validate staging or production deployments.
 | Compose resource files | Compact compose layout is present (`compose.yaml` + environment overlays under `compose/`), plus config/resources/scripts. | `npx @wpmoo/odoo create ...` |
 | `./moo` delegation | `./moo` dispatches fixed daily actions to the matching script and preserves argument pass-through. | `./moo <action> ...` |
 | Doctor checks | Metadata, compose files, scripts, source repo paths, and local tooling checks behave as expected. | `npx @wpmoo/odoo doctor` or `./moo doctor` |
+| Generated Postgres checks | For PostgreSQL 18 environments, doctor validates db mount targets avoid old PG image-specific paths. | `npx @wpmoo/odoo doctor` |
 | Source repo add/remove | Source repository registration and submodule lifecycle behave correctly. | `npx @wpmoo/odoo add-repo ...`, `npx @wpmoo/odoo remove-repo ...` |
+| Source manifest sync | Source repo metadata, `.gitmodules`, and `odoo/custom/manifests/sources.yaml` stay aligned. | `npx @wpmoo/odoo source list`, `npx @wpmoo/odoo source sync` |
 | Module add/remove | Module registration changes are applied to the selected source repo config. | `npx @wpmoo/odoo add-module ...`, `npx @wpmoo/odoo remove-module ...` |
-| Safe reset | Generated files are refreshed without deleting source module code. Legacy user-editable paths from older templates may remain and are reported for manual cleanup. | `npx @wpmoo/odoo reset` |
+| Safe reset | Generated files are refreshed (including `compose.yaml` overlays and env example) without deleting source module code. Local runtime/data directories and custom source layout content are preserved; legacy user-editable paths from older templates may remain and are reported for manual cleanup. | `npx @wpmoo/odoo reset` |
 | Snapshot/restore and lint/pot | These actions are delegated by `./moo` to compose scripts without extra package-side logic. | `./moo snapshot ...`, `./moo restore-snapshot ...`, `./moo lint`, `./moo pot ...` |
 
 ## Compact compose checks
@@ -43,6 +45,17 @@ Default local development uses `compose.yaml` plus `compose/dev.yaml`.
 `WPMOO_ENV=stage` or `WPMOO_ENV=prod` must only be used after production-grade
 secrets and volumes are configured.
 
+For PostgreSQL 18 environments (including `POSTGRES_IMAGE=postgres:18`), ensure db
+volume and tmpfs mount targets use `/var/lib/postgresql` directly:
+
+```text
+- volumes:
+  - db_data:/var/lib/postgresql
+```
+
+Paths such as `/var/lib/postgresql/data` and `/var/lib/postgresql/18/docker` are
+no longer accepted by the package `doctor` check.
+
 ## Safe reset policy
 
 Safe reset intentionally avoids deleting user-editable legacy paths from old
@@ -54,6 +67,41 @@ test/
 .github/
 ```
 
+In addition, safe reset preserves local runtime and source-data state while refreshing
+generated and compose assets:
+
+```text
+.env
+data/
+backups/
+odoo/custom/src/oca/
+odoo/custom/src/external/
+odoo/custom/patches/
+odoo/custom/manifests/
+```
+
+## Source manifest checks
+
+Generated environments include `odoo/custom/manifests/sources.yaml`. The manifest
+records each source repository's type (`private`, `oca`, or `external`), path,
+URL, Odoo branch, and addon boundaries.
+
+Use `source list` to inspect the current manifest view:
+
+```bash
+npx @wpmoo/odoo source list
+```
+
+Use `source sync` after manual submodule or metadata repair to regenerate the
+manifest and normalize `.wpmoo/odoo.json` source entries:
+
+```bash
+npx @wpmoo/odoo source sync
+```
+
+`doctor` fails when manifest entries, metadata entries, and source submodule
+paths diverge.
+
 ## Local verification commands
 
 Run from the `wpmoo-odoo` repository root:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/odoo",
-  "version": "0.8.58",
+  "version": "0.8.60",
   "description": "WPMoo Odoo lifecycle tooling for development, staging, and production workflows.",
   "type": "module",
   "repository": {