@wpmoo/odoo 0.8.68 → 0.9.0

package/dist/scaffold.js

@@ -1,161 +0,0 @@
-import { chmod, mkdir, stat, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { applyExternalAsset, renderExternalAssetCommand, writeTextFile } from './external-assets.js';
-import { markerPath, renderEnvironmentMetadata } from './environment.js';
-import { plannedExternalAssetOptions, renderComposeEnvExample } from './external-templates.js';
-import { cloneRepository, ensureSubmodule, ensureRemoteHasBranch, realGit, stageAll, syncSubmodules, } from './git.js';
-import { renderAgents, renderAppstoreRelease, renderGitignore, renderMooDelegationScript, renderPlaceholder, renderReadme, } from './templates.js';
-import { validateAddonName, validateRepoPath } from './path-validation.js';
-import { renderSourceManifest, sourceManifestEntriesFromMetadata } from './source-manifest.js';
-function validateSourceRepo(repo) {
-    const path = validateRepoPath(repo.path);
-    return {
-        ...repo,
-        path,
-        sourceType: repo.sourceType ?? 'private',
-        addons: repo.addons.map(validateAddonName),
-    };
-}
-function sourceRepoSubmodulePath(repo) {
-    return `odoo/custom/src/${repo.sourceType ?? 'private'}/${repo.path}`;
-}
-function validateScaffoldOptions(options) {
-    return {
-        ...options,
-        sourceRepos: options.sourceRepos.map(validateSourceRepo),
-    };
-}
-export function generatedFiles(options) {
-    const safeOptions = validateScaffoldOptions(options);
-    const sourceDirReadmes = [
-        {
-            path: 'odoo/custom/src/private/README.md',
-            title: 'private',
-            body: 'Project-owned/private addon repositories go here.',
-        },
-        {
-            path: 'odoo/custom/src/oca/README.md',
-            title: 'oca',
-            body: 'OCA repositories go here, for example server-tools, web, queue.',
-        },
-        {
-            path: 'odoo/custom/src/external/README.md',
-            title: 'external',
-            body: 'Non-OCA third-party, vendor, and community addon repositories go here.',
-        },
-        {
-            path: 'odoo/custom/patches/README.md',
-            title: 'patches',
-            body: 'Local patches for upstream/vendor/OCA repositories go here.',
-        },
-        {
-            path: 'odoo/custom/manifests/README.md',
-            title: 'manifests',
-            body: 'Manifest/lock/list files for external sources and pinned revisions go here.',
-        },
-    ];
-    const files = [
-        { path: markerPath, content: renderEnvironmentMetadata(safeOptions) },
-        { path: 'moo', content: renderMooDelegationScript(), mode: 0o755 },
-        { path: '.gitignore', content: renderGitignore() },
-        { path: 'README.md', content: renderReadme(safeOptions) },
-        { path: 'AGENTS.md', content: renderAgents(safeOptions) },
-        { path: 'docs/appstore-release.md', content: renderAppstoreRelease(safeOptions) },
-        {
-            path: 'odoo/custom/manifests/sources.yaml',
-            content: renderSourceManifest(sourceManifestEntriesFromMetadata(safeOptions.sourceRepos, safeOptions.odooVersion)),
-        },
-    ];
-    return [
-        ...files,
-        ...sourceDirReadmes.map((readme) => ({
-            path: readme.path,
-            content: renderPlaceholder(readme.title, readme.body),
-        })),
-    ];
-}
-async function writeGeneratedFiles(target, files) {
-    for (const file of files) {
-        const destination = join(target, file.path);
-        await mkdir(join(destination, '..'), { recursive: true });
-        await writeFile(destination, file.content, 'utf8');
-        if (file.mode !== undefined) {
-            await chmod(destination, file.mode);
-        }
-    }
-}
-async function pathExists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isGitRepository(git, target) {
-    if (!(await pathExists(target))) {
-        return false;
-    }
-    try {
-        const result = await git.run(target, ['rev-parse', '--is-inside-work-tree']);
-        return result.stdout.trim() === 'true';
-    }
-    catch {
-        return false;
-    }
-}
-async function prepareTargetRepository(options, git) {
-    if (await isGitRepository(git, options.target)) {
-        return;
-    }
-    if (await pathExists(options.target)) {
-        throw new Error(`Target exists but is not a Git repository: ${options.target}\n` +
-            'Clone the dev environment repository first, or remove the directory and run the CLI again.');
-    }
-    await mkdir(dirname(options.target), { recursive: true });
-    await cloneRepository(git, dirname(options.target), options.devRepoUrl, options.target);
-}
-export async function scaffold(options, git = realGit) {
-    const safeOptions = validateScaffoldOptions(options);
-    const files = generatedFiles(safeOptions);
-    const externalAssets = plannedExternalAssetOptions(safeOptions);
-    const plannedCommands = [
-        ...externalAssets.map((assetOptions) => renderExternalAssetCommand(assetOptions)),
-        ...safeOptions.sourceRepos.map((repo) => `git submodule add -b ${safeOptions.odooVersion} ${repo.url} ${sourceRepoSubmodulePath(repo)}`),
-    ];
-    if (safeOptions.stage) {
-        plannedCommands.push('git add .');
-    }
-    if (safeOptions.dryRun) {
-        return {
-            plannedFiles: files.map((file) => file.path),
-            plannedCommands,
-        };
-    }
-    if (!safeOptions.skipSubmodules || safeOptions.stage) {
-        await prepareTargetRepository(safeOptions, git);
-    }
-    await writeGeneratedFiles(safeOptions.target, files);
-    for (const assetOptions of externalAssets) {
-        await applyExternalAsset(assetOptions, git);
-    }
-    await writeTextFile(join(safeOptions.target, '.env.example'), renderComposeEnvExample(safeOptions));
-    if (!safeOptions.skipSubmodules) {
-        for (const repo of safeOptions.sourceRepos) {
-            await ensureRemoteHasBranch(git, safeOptions.target, repo.url, safeOptions.odooVersion, safeOptions.initEmptyRepos);
-        }
-        for (const repo of safeOptions.sourceRepos) {
-            await mkdir(join(safeOptions.target, 'odoo/custom/src', repo.sourceType ?? 'private'), { recursive: true });
-            await ensureSubmodule(git, safeOptions.target, repo.url, safeOptions.odooVersion, sourceRepoSubmodulePath(repo));
-        }
-        await syncSubmodules(git, safeOptions.target);
-    }
-    if (safeOptions.stage) {
-        await stageAll(git, safeOptions.target);
-    }
-    return {
-        plannedFiles: files.map((file) => file.path),
-        plannedCommands,
-    };
-}

package/dist/source-actions.js

@@ -1,65 +0,0 @@
-import { defaultOdooVersion, readEnvironmentMetadata, replaceSourceRepos } from './environment.js';
-import { realGit, stageAll } from './git.js';
-import { listGitmoduleSources, readSourceManifest, sourceManifestEntriesFromMetadata, sourceReposFromManifest, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
-function cloneSourceEntries(entries) {
-    return entries.map((entry) => ({
-        ...entry,
-        addons: [...entry.addons],
-    }));
-}
-export async function listSources(target) {
-    const metadata = await readEnvironmentMetadata(target);
-    const manifest = await readSourceManifest(target);
-    if (manifest.sources.length > 0) {
-        return manifest.sources;
-    }
-    if (metadata?.sourceRepos.length) {
-        return sourceManifestEntriesFromMetadata(metadata.sourceRepos, metadata.odooVersion);
-    }
-    return syncManifestFromMetadataAndGitmodules([], metadata?.odooVersion ?? defaultOdooVersion, await listGitmoduleSources(target));
-}
-export function renderSourceList(entries) {
-    if (entries.length === 0) {
-        return 'No source repositories configured.';
-    }
-    return entries
-        .map((entry) => {
-        const branch = entry.branch ? ` @ ${entry.branch}` : '';
-        const addons = entry.addons.length ? ` addons: ${entry.addons.join(', ')}` : '';
-        return `${entry.type}/${entry.path}${branch} -> ${entry.url}${addons}`;
-    })
-        .join('\n');
-}
-export function sourceListJson(entries) {
-    return {
-        schemaVersion: 1,
-        command: 'source list',
-        ok: true,
-        sources: cloneSourceEntries(entries),
-    };
-}
-export function sourceSyncJson(entries, target) {
-    return {
-        schemaVersion: 1,
-        command: 'source sync',
-        ok: true,
-        target,
-        sources: cloneSourceEntries(entries),
-    };
-}
-export async function syncSources(options, git = realGit) {
-    const metadata = await readEnvironmentMetadata(options.target);
-    const manifest = await readSourceManifest(options.target);
-    const gitmodules = await listGitmoduleSources(options.target);
-    const fallbackBranch = metadata?.odooVersion ?? defaultOdooVersion;
-    const baseRepos = metadata?.sourceRepos.length ? metadata.sourceRepos : sourceReposFromManifest(manifest.sources);
-    const entries = syncManifestFromMetadataAndGitmodules(baseRepos, fallbackBranch, gitmodules);
-    await writeSourceManifest(options.target, entries);
-    if (metadata) {
-        await replaceSourceRepos(options.target, sourceReposFromManifest(entries));
-    }
-    if (options.stage) {
-        await stageAll(git, options.target);
-    }
-    return entries;
-}

package/dist/source-manifest.js

@@ -1,338 +0,0 @@
-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)],
-    }));
-}