@quotivity/cpq-inventory-core 0.1.0

package/assets/report/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="referrer" content="no-referrer" />
+    <title>Quotivity CPQ Inventory</title>
+    <script type="module" crossorigin src="./assets/index-CqUjsqpS.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-CKPi--yh.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/lib/banner.d.ts

@@ -0,0 +1,7 @@
+/** Terminal copy shared by the plugin and the standalone script. */
+export declare function launchBanner(org: {
+    name: string;
+    username: string;
+}): string;
+export declare function readyLine(url: string): string;
+//# sourceMappingURL=banner.d.ts.map

package/lib/banner.js

@@ -0,0 +1,13 @@
+/** Terminal copy shared by the plugin and the standalone script. */
+export function launchBanner(org) {
+    return [
+        'Quotivity CPQ Inventory',
+        `Connected to: ${org.name} (${org.username})`,
+        '',
+        'This runs entirely on your machine. Opening your browser...',
+    ].join('\n');
+}
+export function readyLine(url) {
+    return `Report served at ${url} — bound to 127.0.0.1 only. Press Ctrl-C to stop.`;
+}
+//# sourceMappingURL=banner.js.map

package/lib/classify/advancedCondition.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for `SBQQ__AdvancedCondition__c`: a boolean expression over condition indexes, e.g.
+ * `(1 AND 2) OR 3`. Verified grammar: AND and OR with parentheses, nesting to any depth, an index
+ * may appear more than once; NOT is rejected outright by CPQ.
+ */
+export type ConditionExpr = {
+    kind: 'index';
+    index: number;
+} | {
+    kind: 'and';
+    terms: ConditionExpr[];
+} | {
+    kind: 'or';
+    terms: ConditionExpr[];
+};
+export interface ParsedCondition {
+    expr: ConditionExpr;
+    indexes: number[];
+    /** Disjunctive normal form: a list of AND-groups, any one of which satisfies the rule. */
+    dnf: number[][];
+}
+export declare class AdvancedConditionError extends Error {
+    constructor(message: string);
+}
+export declare function parseAdvancedCondition(src: string | null | undefined): ParsedCondition;
+export declare function toDnf(e: ConditionExpr): number[][];
+/** Validates the expression against the indexes actually present on the rule's conditions. */
+export declare function validateAgainstIndexes(src: string | null | undefined, present: number[]): {
+    ok: boolean;
+    missing: number[];
+    error?: string;
+    parsed?: ParsedCondition;
+};
+//# sourceMappingURL=advancedCondition.d.ts.map

package/lib/classify/advancedCondition.js

@@ -0,0 +1,112 @@
+export class AdvancedConditionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AdvancedConditionError';
+    }
+}
+function tokenize(src) {
+    const tokens = [];
+    const re = /\s*(\d+|AND|OR|NOT|\(|\))\s*/giy;
+    let pos = 0;
+    while (pos < src.length) {
+        re.lastIndex = pos;
+        const m = re.exec(src);
+        if (!m || m.index !== pos)
+            throw new AdvancedConditionError(`unexpected text at position ${pos}: "${src.slice(pos, pos + 12)}"`);
+        const raw = m[1].toUpperCase();
+        if (raw === 'NOT')
+            throw new AdvancedConditionError('Only the following logical operators are accepted: AND, OR.');
+        if (raw === 'AND')
+            tokens.push({ t: 'and' });
+        else if (raw === 'OR')
+            tokens.push({ t: 'or' });
+        else if (raw === '(')
+            tokens.push({ t: '(' });
+        else if (raw === ')')
+            tokens.push({ t: ')' });
+        else
+            tokens.push({ t: 'num', v: Number(raw) });
+        pos = re.lastIndex;
+    }
+    return tokens;
+}
+export function parseAdvancedCondition(src) {
+    const text = (src ?? '').trim();
+    if (!text)
+        throw new AdvancedConditionError('empty expression');
+    const tokens = tokenize(text);
+    let i = 0;
+    const peek = () => tokens[i];
+    const next = () => tokens[i++];
+    function primary() {
+        const tok = next();
+        if (!tok)
+            throw new AdvancedConditionError('unexpected end of expression');
+        if (tok.t === 'num')
+            return { kind: 'index', index: tok.v };
+        if (tok.t === '(') {
+            const inner = orExpr();
+            const close = next();
+            if (close?.t !== ')')
+                throw new AdvancedConditionError('missing closing parenthesis');
+            return inner;
+        }
+        throw new AdvancedConditionError(`unexpected token ${tok.t}`);
+    }
+    function andExpr() {
+        const terms = [primary()];
+        while (peek()?.t === 'and') {
+            next();
+            terms.push(primary());
+        }
+        return terms.length === 1 ? terms[0] : { kind: 'and', terms };
+    }
+    function orExpr() {
+        const terms = [andExpr()];
+        while (peek()?.t === 'or') {
+            next();
+            terms.push(andExpr());
+        }
+        return terms.length === 1 ? terms[0] : { kind: 'or', terms };
+    }
+    const expr = orExpr();
+    if (i < tokens.length)
+        throw new AdvancedConditionError('unexpected trailing tokens');
+    const indexes = [...new Set(collect(expr))].sort((a, b) => a - b);
+    return { expr, indexes, dnf: toDnf(expr) };
+}
+function collect(e) {
+    if (e.kind === 'index')
+        return [e.index];
+    return e.terms.flatMap(collect);
+}
+export function toDnf(e) {
+    if (e.kind === 'index')
+        return [[e.index]];
+    if (e.kind === 'or')
+        return e.terms.flatMap(toDnf);
+    // AND: cartesian product of the children's DNF groups
+    let groups = [[]];
+    for (const term of e.terms) {
+        const sub = toDnf(term);
+        const nextGroups = [];
+        for (const g of groups)
+            for (const s of sub)
+                nextGroups.push([...new Set([...g, ...s])].sort((a, b) => a - b));
+        groups = nextGroups;
+    }
+    return groups;
+}
+/** Validates the expression against the indexes actually present on the rule's conditions. */
+export function validateAgainstIndexes(src, present) {
+    try {
+        const parsed = parseAdvancedCondition(src);
+        const have = new Set(present);
+        const missing = parsed.indexes.filter((n) => !have.has(n));
+        return { ok: missing.length === 0, missing, parsed };
+    }
+    catch (err) {
+        return { ok: false, missing: [], error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=advancedCondition.js.map

package/lib/classify/formula.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Calculated-pricing formula grammar check. The report names the specific limit a formula breaches
+ * rather than saying "outside the grammar".
+ */
+export declare const SUPPORTED_FUNCTIONS: readonly ["IF", "CASE", "AND", "OR", "NOT", "ISBLANK", "BLANKVALUE", "MIN", "MAX"];
+export declare const AND_OR_MIN_ARGS = 2;
+export declare const AND_OR_MAX_ARGS = 5;
+export declare const MAX_NESTING = 10;
+export declare const MAX_LENGTH = 3900;
+export declare const MAX_IF_COUNT = 20;
+export interface FormulaCheck {
+    ok: boolean;
+    breaches: string[];
+    functions: string[];
+}
+interface Call {
+    name: string;
+    args: number;
+    depth: number;
+}
+/** Parses function calls, counting arguments at the top level of each call. */
+export declare function parseCalls(formula: string): {
+    calls: Call[];
+    maxDepth: number;
+    balanced: boolean;
+};
+export declare function checkFormula(formula: string | null | undefined): FormulaCheck;
+export {};
+//# sourceMappingURL=formula.d.ts.map

package/lib/classify/formula.js

@@ -0,0 +1,125 @@
+/**
+ * Calculated-pricing formula grammar check. The report names the specific limit a formula breaches
+ * rather than saying "outside the grammar".
+ */
+export const SUPPORTED_FUNCTIONS = [
+    'IF',
+    'CASE',
+    'AND',
+    'OR',
+    'NOT',
+    'ISBLANK',
+    'BLANKVALUE',
+    'MIN',
+    'MAX',
+];
+export const AND_OR_MIN_ARGS = 2;
+export const AND_OR_MAX_ARGS = 5;
+export const MAX_NESTING = 10;
+export const MAX_LENGTH = 3_900;
+export const MAX_IF_COUNT = 20;
+/** Parses function calls, counting arguments at the top level of each call. */
+export function parseCalls(formula) {
+    const calls = [];
+    const stack = [];
+    let depth = 0;
+    let maxDepth = 0;
+    let i = 0;
+    let inString = null;
+    while (i < formula.length) {
+        const ch = formula[i];
+        if (inString) {
+            if (ch === '\\')
+                i += 1;
+            else if (ch === inString)
+                inString = null;
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            const top = stack[stack.length - 1];
+            if (top)
+                top.hasContent = true;
+            i += 1;
+            continue;
+        }
+        const ident = /^[A-Za-z_][A-Za-z0-9_]*/.exec(formula.slice(i));
+        if (ident && /^\s*\(/.test(formula.slice(i + ident[0].length))) {
+            const name = ident[0].toUpperCase();
+            const parenAt = formula.indexOf('(', i + ident[0].length);
+            const top = stack[stack.length - 1];
+            if (top)
+                top.hasContent = true;
+            stack.push({ name, args: 0, hasContent: false });
+            depth += 1;
+            maxDepth = Math.max(maxDepth, depth);
+            i = parenAt + 1;
+            continue;
+        }
+        if (ident) {
+            const top = stack[stack.length - 1];
+            if (top)
+                top.hasContent = true;
+            i += ident[0].length;
+            continue;
+        }
+        if (ch === '(') {
+            stack.push({ name: '(', args: 0, hasContent: false });
+            depth += 1;
+            maxDepth = Math.max(maxDepth, depth);
+        }
+        else if (ch === ')') {
+            const top = stack.pop();
+            depth = Math.max(0, depth - 1);
+            if (top && top.name !== '(') {
+                calls.push({ name: top.name, args: top.hasContent ? top.args + 1 : 0, depth });
+            }
+            const parent = stack[stack.length - 1];
+            if (parent)
+                parent.hasContent = true;
+        }
+        else if (ch === ',') {
+            const top = stack[stack.length - 1];
+            if (top && top.name !== '(')
+                top.args += 1;
+        }
+        else if (!/\s/.test(ch)) {
+            const top = stack[stack.length - 1];
+            if (top)
+                top.hasContent = true;
+        }
+        i += 1;
+    }
+    return { calls, maxDepth, balanced: stack.length === 0 && !inString };
+}
+export function checkFormula(formula) {
+    const text = (formula ?? '').trim();
+    const breaches = [];
+    if (!text)
+        return { ok: true, breaches, functions: [] };
+    const { calls, maxDepth, balanced } = parseCalls(text);
+    const functions = [...new Set(calls.map((c) => c.name))];
+    if (!balanced)
+        breaches.push('unbalanced parentheses or quotes');
+    if (text.length > MAX_LENGTH)
+        breaches.push(`${text.length} characters, over the ${MAX_LENGTH}-character limit`);
+    if (maxDepth > MAX_NESTING)
+        breaches.push(`nested ${maxDepth} levels deep, over the limit of ${MAX_NESTING}`);
+    const ifs = calls.filter((c) => c.name === 'IF').length;
+    if (ifs > MAX_IF_COUNT)
+        breaches.push(`${ifs} IF calls, over the limit of ${MAX_IF_COUNT}`);
+    const supported = new Set(SUPPORTED_FUNCTIONS);
+    for (const fn of functions) {
+        if (!supported.has(fn))
+            breaches.push(`${fn}() is not in the calculated pricing grammar`);
+    }
+    for (const c of calls) {
+        if ((c.name === 'AND' || c.name === 'OR') &&
+            (c.args < AND_OR_MIN_ARGS || c.args > AND_OR_MAX_ARGS)) {
+            breaches.push(`${c.name}() takes ${AND_OR_MIN_ARGS} to ${AND_OR_MAX_ARGS} arguments; this one has ${c.args}`);
+        }
+    }
+    return { ok: breaches.length === 0, breaches: [...new Set(breaches)], functions };
+}
+//# sourceMappingURL=formula.js.map

package/lib/classify/index.d.ts

@@ -0,0 +1,80 @@
+import type { Extraction } from '../extract/index.js';
+import { type BulkTouch } from '../liveness.js';
+import type { ObjectRead } from '../soql.js';
+import type { BucketId } from '../types.js';
+import { type RowId } from './rules.js';
+export interface Listing {
+    rowId: RowId;
+    bucket: BucketId;
+}
+export interface ClassifiedRecord {
+    id: string;
+    object: string;
+    name: string;
+    primary: Listing;
+    secondary: Listing[];
+    alive: boolean;
+    /** Free-text facts the report can print (formula breach, hooks implemented, ...). */
+    details: string[];
+}
+/** Count-only rows: the tool has the aggregate but not the records (contracts, quotes, currencies). */
+export interface Tally {
+    rowId: RowId;
+    bucket: BucketId;
+    count: number;
+    alive: number;
+    details?: string[];
+}
+export interface ObjectStat {
+    object: string;
+    status: ObjectRead['status'];
+    count: number;
+    retrieved: number;
+    classified: number;
+    residue: number;
+    partial: boolean;
+    bulkTouch: BulkTouch | null;
+}
+export interface Classification {
+    records: ClassifiedRecord[];
+    tallies: Tally[];
+    residue: {
+        object: string;
+        id: string;
+        name: string;
+    }[];
+    objects: ObjectStat[];
+    facts: ClassificationFacts;
+}
+export interface ClassificationFacts {
+    bundles: number;
+    nestingDepth: number;
+    featureCount: number;
+    optionCount: number;
+    approverCount: number;
+    medianApprovalCycleDays: number | null;
+    approvalHistoryCount: number;
+    approvalRulesFired: number;
+    contractedPriceAccounts: number;
+    discountTierCount: number;
+    templateSectionCount: number;
+    templateContentCount: number;
+    deadSummaryVariables: number;
+    qcpHooks: Record<string, string[]>;
+    ruleConditionProblems: {
+        rule: string;
+        problem: string;
+    }[];
+    attributeCount: number;
+    currencies: string[];
+    multiCurrency: boolean;
+    advancedApprovalsInstalled: boolean;
+    nativeApprovalProcesses: number;
+    subscriptionCount: number;
+    productsNeverQuoted: number;
+    amendRenewShareLastYear: number | null;
+    lastYear: number | null;
+}
+export declare function classifyAll(ex: Extraction): Classification;
+export declare function median(values: number[]): number | null;
+//# sourceMappingURL=index.d.ts.map