@bergetai/odoo-cli 0.1.0

package/dist/filter.js

@@ -0,0 +1,61 @@
+import { usageError } from "./errors.js";
+/**
+ * Parse a --domain JSON array verbatim (SPEC §4.6). Must be a JSON array of
+ * domain clauses; anything else is a usage error quoting the input.
+ */
+export function parseDomain(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw usageError(`invalid --domain JSON: ${JSON.stringify(raw)}`, 'expected an Odoo domain as a JSON array, e.g. [["is_company","=",true]]');
+    }
+    if (!Array.isArray(parsed)) {
+        throw usageError(`invalid --domain: expected a JSON array, got ${typeof parsed}`, 'expected an Odoo domain as a JSON array, e.g. [["is_company","=",true]]');
+    }
+    return parsed;
+}
+/** Parse a --filter value as a JSON scalar when possible, else a string. */
+export function parseFilterScalar(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "")
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return raw;
+    }
+}
+/**
+ * Build domain clauses from repeatable --filter f=v flags (SPEC §4.6).
+ * many2one fields only accept numeric ids — a non-numeric value is a usage
+ * error pointing at the resolution flags, never a silently empty result.
+ */
+export function buildFilterClauses(filters, fields, resolutionHints) {
+    const clauses = [];
+    for (const filter of filters) {
+        const eq = filter.indexOf("=");
+        if (eq <= 0) {
+            throw usageError(`invalid --filter ${JSON.stringify(filter)}`, "expected the form field=value");
+        }
+        const field = filter.slice(0, eq);
+        const rawValue = filter.slice(eq + 1);
+        const meta = fields.get(field);
+        if (!meta) {
+            throw usageError(`unknown field ${JSON.stringify(field)} in --filter`, "check the field name with `odoo crm leads show <id> --all-fields`");
+        }
+        const value = parseFilterScalar(rawValue);
+        if (meta.type === "many2one" &&
+            typeof value !== "number" &&
+            value !== false) {
+            const hintFlag = resolutionHints[field];
+            throw usageError(`--filter ${field}=... only accepts a numeric record id (got ${JSON.stringify(rawValue)})`, hintFlag
+                ? `use ${hintFlag} for name-based matching, or --domain for arbitrary domains`
+                : "use --domain for non-id matching");
+        }
+        clauses.push([field, "=", value]);
+    }
+    return clauses;
+}

package/dist/global-options.js

@@ -0,0 +1,40 @@
+import { usageError } from "./errors.js";
+export const DEFAULT_TIMEOUT = "30s";
+/** Wire the §3 global flags onto a commander program/command. */
+export function applyGlobalOptions(cmd) {
+    cmd.option("--json", "emit a single JSON object on stdout");
+    cmd.option("--dry-run, -n", "preview the mutation without applying it");
+    cmd.option("--url <url>", "Odoo server URL (env: ODOO_URL)");
+    cmd.option("--db <name>", "database name (env: ODOO_DB)");
+    cmd.option("--username <login>", "login (env: ODOO_USERNAME)");
+    cmd.option("--api-key-file <path>", "read the API key from a file");
+    cmd.option("--allow-insecure-http", "permit plain HTTP to non-localhost hosts");
+    cmd.option("--timeout <duration>", `per-request timeout (default: ${DEFAULT_TIMEOUT}, env: ODOO_TIMEOUT)`);
+    cmd.option("--quiet, -q", "suppress non-essential stderr output");
+    cmd.option("--verbose", "debug output on stderr (secrets redacted)");
+    cmd.option("--no-color", "disable color output");
+}
+/**
+ * Enforce SPEC §11: HTTPS required unless the host is localhost/127.0.0.1;
+ * plain HTTP elsewhere needs --allow-insecure-http.
+ */
+export function enforceTransportSecurity(url, allowInsecureHttp) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw usageError(`invalid URL ${JSON.stringify(url)}`, "check --url");
+    }
+    if (parsed.protocol === "https:")
+        return;
+    if (parsed.protocol === "http:") {
+        const host = parsed.hostname;
+        if (host === "localhost" || host === "127.0.0.1")
+            return;
+        if (allowInsecureHttp)
+            return;
+        throw usageError(`refusing plain HTTP to non-localhost host ${JSON.stringify(host)}`, "use HTTPS, or pass --allow-insecure-http for dev/CI environments");
+    }
+    throw usageError(`unsupported URL scheme ${JSON.stringify(parsed.protocol)} in ${JSON.stringify(url)}`, "use an http(s):// URL");
+}

package/dist/model.js

@@ -0,0 +1,149 @@
+import { conflictError, notFoundError } from "./errors.js";
+import { XmlRpcFaultError } from "./xmlrpc.js";
+/** Cached fields_get metadata for one model (one call per model per process,
+ * SPEC §4.6).
+ */
+export class ModelFields {
+    fields;
+    static cache = new Map();
+    constructor(fields) {
+        this.fields = fields;
+    }
+    static async load(client, model) {
+        const existing = ModelFields.cache.get(model);
+        if (existing)
+            return existing;
+        const promise = ModelFields.uncachedLoad(client, model);
+        ModelFields.cache.set(model, promise);
+        // Drop the cache entry on failure so a later retry can re-attempt.
+        promise.catch(() => ModelFields.cache.delete(model));
+        return promise;
+    }
+    static async uncachedLoad(client, model) {
+        let result;
+        try {
+            result = await client.executeKw(model, "fields_get", [[]], {
+                attributes: ["string", "type", "relation"],
+            });
+        }
+        catch (error) {
+            throw mapModelMissing(error, model);
+        }
+        if (typeof result !== "object" || result === null) {
+            throw notFoundError("model_not_found", `model ${JSON.stringify(model)} not found on the server`, `the ${model.split(".")[0]} module may not be installed`);
+        }
+        return new ModelFields(result);
+    }
+    get(name) {
+        return this.fields[name];
+    }
+}
+const INVALID_MODEL_RE = /(?:Invalid model|Model not found)[: ]+['"]?([\w.]+)['"]?/;
+/**
+ * §1: if a module's model is absent from the server (e.g. helpdesk.ticket —
+ * Helpdesk is an Enterprise app), fail with exit 4 and a hint naming the
+ * module rather than a raw server fault.
+ */
+function mapModelMissing(error, model) {
+    if (error instanceof XmlRpcFaultError) {
+        const match = INVALID_MODEL_RE.exec(error.faultString);
+        if (match) {
+            const module = model.split(".")[0];
+            return notFoundError("model_not_found", `${module} module not installed (model '${model}' not found)`, `install the ${module} app on the server to use these commands`);
+        }
+    }
+    return error;
+}
+/**
+ * Resolve a record reference by numeric id or case-insensitive name
+ * (SPEC §4.3). Exactly one match required; zero matches list available
+ * options (exit 4), multiple matches list candidates (exit 5). Never guesses.
+ */
+export async function resolveReference(client, model, input, opts = {}) {
+    const label = opts.label ?? model;
+    const searchFields = opts.searchFields ?? ["name"];
+    const baseDomain = opts.domain ?? [];
+    // Numeric ids are used verbatim but still verified — with active_test off
+    // so an archived record is reported as archived, not "not found" (§4.3).
+    // Only models with an `active` field carry the archive concept; requesting
+    // `active` on a model that lacks it faults server-side, so introspect.
+    if (/^\d+$/.test(input)) {
+        const id = Number(input);
+        const refMeta = await ModelFields.load(client, model);
+        const hasActive = refMeta.get("active") !== undefined;
+        const fields = hasActive ? ["display_name", "active"] : ["display_name"];
+        const rows = (await client.executeKw(model, "search_read", [[["id", "=", id]]], {
+            fields,
+            limit: 1,
+            context: { active_test: false },
+        }));
+        if (rows.length === 0) {
+            throw notFoundError("reference_not_found", `no ${label} with id ${id}`);
+        }
+        if (hasActive && rows[0].active === false) {
+            throw notFoundError("reference_archived", `${label} ${id} "${rows[0].display_name}" is archived`);
+        }
+        return { id, name: rows[0].display_name };
+    }
+    // Name resolution: OR across searchable fields. `exactFields` use a
+    // case-sensitive `=` (e.g. res.partner email); `searchFields` use ilike.
+    const nameClauses = [];
+    for (const field of searchFields) {
+        nameClauses.push([field, "ilike", input]);
+    }
+    for (const field of opts.exactFields ?? []) {
+        nameClauses.push([field, "=", input]);
+    }
+    const domain = nameClauses.length === 1
+        ? [...baseDomain, nameClauses[0]]
+        : [...baseDomain, ...orChain(nameClauses)];
+    const rows = (await client.executeKw(model, "search_read", [domain], {
+        fields: ["display_name"],
+        limit: 20,
+    }));
+    if (rows.length === 1) {
+        return { id: rows[0].id, name: rows[0].display_name };
+    }
+    if (rows.length === 0) {
+        const options = await listOptions(client, model, baseDomain);
+        throw notFoundError("reference_not_found", `no ${label} named "${input}"`, options ? `available: ${options}` : undefined);
+    }
+    throw conflictError("ambiguous_reference", `"${input}" matches ${rows.length} ${label} records`, `candidates: ${rows.map((r) => `${r.display_name} (${r.id})`).join(", ")} — use a numeric id`);
+}
+function orChain(clauses) {
+    // Odoo prefix notation: OR-ing n clauses takes n-1 "|" operators, each
+    // consuming the next two expressions. [a, b, c] -> ["|", "|", a, b, c]
+    // which parses as ((a | b) | c).
+    if (clauses.length <= 1)
+        return clauses;
+    const operators = Array.from({ length: clauses.length - 1 }, () => "|");
+    return [...operators, ...clauses];
+}
+async function listOptions(client, model, domain) {
+    const rows = (await client.executeKw(model, "search_read", [domain], {
+        fields: ["display_name"],
+        limit: 10,
+        order: "id asc",
+    }));
+    if (rows.length === 0)
+        return undefined;
+    return rows.map((r) => `${r.display_name} (${r.id})`).join(", ");
+}
+/**
+ * Build the scoping domain for stage resolution under a --team
+ * (SPEC §4.3): CRM stages may be team-less (shared), so an inclusive
+ * scope matches the team's stages plus global ones; Helpdesk scopes
+ * strictly to the team, introspecting the stage model's team-link field
+ * (team_id m2o vs team_ids m2m) rather than assuming it.
+ */
+export async function stageScopeDomain(client, stageModel, scope, teamId) {
+    if (scope === "inclusive") {
+        return [["team_id", "in", [teamId, false]]];
+    }
+    const stageMeta = await ModelFields.load(client, stageModel);
+    if (stageMeta.get("team_id"))
+        return [["team_id", "=", teamId]];
+    if (stageMeta.get("team_ids"))
+        return [["team_ids", "in", [teamId]]];
+    return [];
+}