@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/coverage-registry.js

@@ -0,0 +1,76 @@
+import { APP_COVERAGE } from "./lanes/app-coverage.js";
+import { DICTIONARY_COVERAGE } from "./lanes/dictionary-coverage.js";
+import { B2_COVERAGE } from "./lanes/b2-registration-coverage.js";
+import { BUSINESSRULE_COVERAGE } from "./lanes/businessrule-coverage.js";
+import { ENVIRONMENT_COVERAGE } from "./lanes/environment-coverage.js";
+import { DATARULE_COVERAGE } from "./lanes/datarule-coverage.js";
+import { FIELD_COVERAGE } from "./lanes/field-coverage.js";
+import { FORM_COVERAGE } from "./lanes/form-coverage.js";
+import { LIST_VIEW_COVERAGE } from "./lanes/list-view-coverage.js";
+import { MODEL_COVERAGE } from "./lanes/model-coverage.js";
+import { ONLINE_JS_COVERAGE } from "./lanes/online-js-coverage.js";
+import { RULE_LIFECYCLE_COVERAGE } from "./lanes/rule-lifecycle-coverage.js";
+import { RUNTIME_DATA_COVERAGE } from "./lanes/runtime-data-coverage.js";
+import { WORKFLOW_COVERAGE } from "./lanes/workflow-coverage.js";
+import { REPORT_COVERAGE } from "./lanes/report-coverage.js";
+/**
+ * Every lane's structured capability declaration, gathered in one frozen
+ * registry. This is the source the runtime coverage gate consults, and the
+ * source the manifest generator/validator aligns against.
+ */
+const DECLARATIONS = Object.freeze([
+    ...ENVIRONMENT_COVERAGE,
+    ...APP_COVERAGE,
+    ...DICTIONARY_COVERAGE,
+    ...MODEL_COVERAGE,
+    ...FIELD_COVERAGE,
+    ...DATARULE_COVERAGE,
+    ...FORM_COVERAGE,
+    ...BUSINESSRULE_COVERAGE,
+    ...RULE_LIFECYCLE_COVERAGE,
+    ...RUNTIME_DATA_COVERAGE,
+    ...WORKFLOW_COVERAGE,
+    ...ONLINE_JS_COVERAGE,
+    ...B2_COVERAGE,
+    ...LIST_VIEW_COVERAGE,
+    ...REPORT_COVERAGE,
+]);
+export function laneCoverageDeclarations() {
+    return DECLARATIONS;
+}
+/**
+ * Build-time alignment: every declaration names a real manifest capability,
+ * carries evidence, does not double-claim a tool, and any capability that
+ * claims tools maps to an executable/partial manifest item.
+ */
+export function assertDeclarationsAlignWithManifest(manifest) {
+    const owner = new Map();
+    for (const declaration of DECLARATIONS) {
+        const where = `${declaration.lane} / "${declaration.capability}"`;
+        if (!declaration.capability.trim())
+            throw new Error(`coverage declaration ${declaration.lane} requires a capability title`);
+        if (!declaration.lane.trim())
+            throw new Error(`coverage declaration ${where} requires a lane id`);
+        if (declaration.evidence.length === 0)
+            throw new Error(`coverage declaration ${where} requires at least one evidence anchor`);
+        const item = manifest.items.find((candidate) => candidate.lane === declaration.lane && candidate.capability === declaration.capability);
+        if (!item)
+            throw new Error(`coverage declaration ${where} has no matching manifest item`);
+        if (declaration.tools.length > 0 && item.status !== "executable" && item.status !== "partial") {
+            throw new Error(`coverage declaration ${where} claims tools but the manifest item is ${item.status}`);
+        }
+        const ledgerPaths = new Set((item.evidence ?? []).map((anchor) => anchor.path));
+        if (ledgerPaths.size > 0 && !declaration.evidence.some((anchor) => ledgerPaths.has(anchor))) {
+            throw new Error(`coverage declaration ${where} evidence anchors are not present in the manifest item's evidence ledger`);
+        }
+        for (const toolClaim of declaration.tools) {
+            if (!toolClaim.scope.trim())
+                throw new Error(`coverage declaration ${where} claims ${toolClaim.tool} without a scope`);
+            const previous = owner.get(toolClaim.tool);
+            if (previous)
+                throw new Error(`tool ${toolClaim.tool} is declared twice: ${previous} and ${where}`);
+            owner.set(toolClaim.tool, where);
+        }
+    }
+}
+//# sourceMappingURL=coverage-registry.js.map

package/dist/coverage.js

@@ -0,0 +1,130 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { laneCoverageDeclarations } from "./coverage-registry.js";
+export class CoverageBoundaryError extends Error {
+    citation;
+    constructor(citation) {
+        super(citation.message);
+        this.citation = citation;
+    }
+}
+let cachedManifest = null;
+export function loadCoverageManifest() {
+    if (cachedManifest)
+        return cachedManifest;
+    const root = join(dirname(fileURLToPath(import.meta.url)), "..", "coverage");
+    cachedManifest = JSON.parse(readFileSync(join(root, "m1-coverage-manifest-v1.json"), "utf8"));
+    return cachedManifest;
+}
+export function coverageItemsByLane(manifest) {
+    return new Map(manifest.items.map((item) => [item.lane, item]));
+}
+/**
+ * Structured allowed-scope index built from the lane declarations joined to
+ * the manifest's capability status. The key is `lane\0scope`; each value is
+ * the manifest item the claim cites. A lane typo in a declaration surfaces at
+ * build time (`assertCoverageConsistency`) and here as a missing manifest item.
+ */
+const allowedCache = new WeakMap();
+function allowedScopes(manifest) {
+    const cached = allowedCache.get(manifest);
+    if (cached)
+        return cached;
+    const index = new Map();
+    for (const declaration of laneCoverageDeclarations()) {
+        const item = manifest.items.find((candidate) => candidate.lane === declaration.lane && candidate.capability === declaration.capability);
+        if (!item) {
+            throw new Error(`coverage declaration ${declaration.lane} / "${declaration.capability}" has no manifest item; ` +
+                "add the capability to coverage/m1-coverage-manifest-v1.json");
+        }
+        for (const claim of declaration.tools)
+            index.set(`${declaration.lane}\u0000${claim.scope}`, item);
+    }
+    allowedCache.set(manifest, index);
+    return index;
+}
+/**
+ * Map a tool's declared `(lane, scope)` onto the manifest. A call is allowed
+ * only when a declared capability claims that exact pair and its manifest item
+ * is executable/partial; blocked, static-only, and unsupported items always
+ * reject with a citation.
+ */
+/**
+ * Ticket 84 — self-correcting lane hints. Users pass capability nicknames
+ * ("listview") instead of lane ids ("W1-list-view"); normalize both sides
+ * (lowercase, strip the M1/M2/W1/B1/G1/W7/S25 prefix segment) and suggest the
+ * closest declared lane.
+ */
+function suggestLaneId(manifest, requested) {
+    const normalize = (value) => value.toLowerCase().replace(/^[a-z]\d+-/, "").replace(/-/g, "");
+    const target = normalize(requested);
+    if (!target)
+        return undefined;
+    const lanes = [...new Set(manifest.items.map((item) => item.lane))];
+    return lanes.find((lane) => normalize(lane) === target || lane.toLowerCase().endsWith(`-${requested.toLowerCase()}`));
+}
+export function assertWithinCoverage(manifest, lane, requestedScope) {
+    const claimed = allowedScopes(manifest).get(`${lane}\u0000${requestedScope}`);
+    if (claimed)
+        return claimed;
+    const laneItems = manifest.items.filter((candidate) => candidate.lane === lane);
+    if (laneItems.length === 0) {
+        const suggestion = suggestLaneId(manifest, lane);
+        const validLanes = [...new Set(manifest.items.map((item) => item.lane))].join("、");
+        throw new CoverageBoundaryError({
+            code: "capability-out-of-coverage",
+            lane,
+            capability: "<unknown>",
+            status: "blocked",
+            reason: "lane is not present in the M1 coverage manifest",
+            message: `rejected: lane ${lane} is not in coverage manifest ` +
+                `${manifest.manifest_type} v${manifest.schema_version}; no live-proven evidence exists` +
+                (suggestion ? `；capability 取 lane id，不是能力昵称——你传的 "${lane}" 最接近 "${suggestion}"；合法取值：${validLanes}；省略 capability 即自动按工具所属 lane 校验` : `；合法 lane 取值：${validLanes}`),
+        });
+    }
+    const runtimeItem = laneItems.find((candidate) => candidate.status === "executable" || candidate.status === "partial");
+    if (!runtimeItem) {
+        throw new CoverageBoundaryError(citationFor(laneItems[0], requestedScope));
+    }
+    throw new CoverageBoundaryError({
+        code: "capability-out-of-coverage",
+        lane: runtimeItem.lane,
+        capability: runtimeItem.capability,
+        status: runtimeItem.status,
+        reason: `requested scope "${requestedScope}" is not declared for ${runtimeItem.capability}`,
+        message: `rejected: requested scope "${requestedScope}" exceeds live-proven scope of ` +
+            `${runtimeItem.capability} (${runtimeItem.status}); it is not a declared scope of lane ${lane}`,
+    });
+}
+function citationFor(item, requestedScope) {
+    return {
+        code: "capability-out-of-coverage",
+        lane: item.lane,
+        capability: item.capability,
+        status: item.status,
+        reason: item.excluded_or_unsupported_reason ??
+            `requested scope "${requestedScope}" is not runtime coverage for lane ${item.lane}`,
+        message: `rejected: ${item.capability} is ${item.status} in coverage manifest ` +
+            `(${item.excluded_or_unsupported_reason ?? "not a runtime coverage claim"}); ` +
+            `citing lane ${item.lane}`,
+    };
+}
+/**
+ * Version-family compatibility notice.
+ *
+ * OMC's coverage manifest is anchored on the CloudPivot 8.6 family. Rather than
+ * hard-failing every other version, the gate is now advisory: a detected version
+ * outside the anchored family is ACCEPTED and this returns the notice to surface
+ * (omc is built on 8.6; other products/versions run in compatibility mode and
+ * some faces may not apply). Returns undefined when the version is inside the
+ * family, or when there is no evidence to judge (the caller keeps its own
+ * fail-closed behavior for missing evidence).
+ */
+export function versionFamilyNotice(manifest, detectedVersion) {
+    if (detectedVersion.startsWith(manifest.version_family + "."))
+        return undefined;
+    return (`兼容模式：检测到 CloudPivot ${detectedVersion}，不在 OMC 锚定的 ${manifest.version_family} 族` +
+        `（锚点 ${manifest.anchor_version}）。OMC 基于 8.6 构建，非 8.6 环境按兼容支持，部分能力面可能不适用。`);
+}
+//# sourceMappingURL=coverage.js.map

package/dist/data-list-filter.js

@@ -0,0 +1,114 @@
+import { RUNTIME_QUERY_OPERATORS } from "./lanes/runtime-data-contract.js";
+export const SIMPLE_OP_MAP = {
+    eq: "Eq",
+    equals: "Eq",
+    neq: "NotEq",
+    notEquals: "NotEq",
+    gt: "Gt",
+    lt: "Lt",
+    gte: "Gte",
+    lte: "Lte",
+    like: "Like",
+    contains: "Like",
+    notlike: "NotLike",
+    isnull: "IsNull",
+    isNull: "IsNull",
+    isnotnull: "IsNotNull",
+    isNotNull: "IsNotNull",
+    in: "In",
+    notin: "NotIn",
+    between: "Between",
+    notbetween: "NotBetween",
+};
+export class FilterDslError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/**
+ * Translate the simplified DSL into the runtime `queryCondition` shape —
+ * `List<List<List<FilterModel>>>` consumed by /api/api/runtime/query/list
+ * (QueryDataVO.queryCondition). Semantics per decompiled 8.6.26 source
+ * (BizObjectFacadeImpl.getFiltersByQueryParam / buildFilter):
+ * level 1 = AND across groups, level 2 = OR across and-groups,
+ * level 3 = AND across leaves. A 2-level array fails JSON deserialization
+ * with errcode 10009 类型转换异常.
+ * leaf  -> [[[leaf]]]
+ * and(k) -> [[[l1..lk]]]
+ * or(k)  -> [[[l1]..[lk]]]
+ * Mixed nesting deeper than one group level is refused (no silent re-binding).
+ */
+export function toQueryCondition(payload) {
+    if (payload.rawCondition !== undefined) {
+        if (payload.rawCondition === null || typeof payload.rawCondition !== "object" || !Array.isArray(payload.rawCondition))
+            throw new FilterDslError("invalid-raw-condition", "rawCondition must be the platform queryCondition array (and>or>and>leaf)");
+        return payload.rawCondition;
+    }
+    if (payload.filterGroup !== undefined)
+        return [translateGroup(payload.filterGroup, 0)];
+    const clauses = payload.filters ?? (payload.filter === undefined ? [] : [payload.filter]);
+    if (clauses.length === 0)
+        return undefined;
+    return [[clauses.map((clause) => translateClause(clause))]];
+}
+function translateGroup(group, depth) {
+    if (depth > 0)
+        throw new FilterDslError("filter-depth-exceeded", "nested groups inside filterGroup are not supported by the runtime condition format");
+    if (!Array.isArray(group.clauses) || group.clauses.length === 0)
+        throw new FilterDslError("empty-group-clauses", "filterGroup.clauses must be non-empty");
+    if (group.op === "and")
+        return [group.clauses.map((clause) => ("clauses" in clause ? badNested() : translateClause(clause)))];
+    return group.clauses.map((clause) => ("clauses" in clause ? badNested() : [translateClause(clause)]));
+}
+function badNested() {
+    throw new FilterDslError("filter-depth-exceeded", "nested groups inside filterGroup are not supported by the runtime condition format");
+}
+function translateClause(clause) {
+    if (!clause || typeof clause !== "object" || !(clause.op in SIMPLE_OP_MAP))
+        throw new FilterDslError("invalid-op", `unsupported filter op '${String(clause?.op)}'`);
+    const field = String(clause.field ?? "").trim();
+    if (!field)
+        throw new FilterDslError("missing-field", "filter field is required");
+    return {
+        propertyCode: field,
+        propertyValue: encodeValue(clause.op, clause.value),
+        queryFilterType: SIMPLE_OP_MAP[clause.op],
+    };
+}
+function encodeValue(op, value) {
+    const wireOp = SIMPLE_OP_MAP[op];
+    // Encoding itself comes from the shared operator table (the same table the
+    // fake evaluator matches through) so compiler and evaluator cannot drift.
+    const operator = RUNTIME_QUERY_OPERATORS[wireOp];
+    if (!operator)
+        throw new FilterDslError("invalid-op", `unsupported filter op '${String(op)}'`);
+    if (wireOp !== "IsNull" && wireOp !== "IsNotNull" && (value === null || value === undefined))
+        throw new FilterDslError("missing-value", `filter op '${op}' requires a value`);
+    return operator.encode(value);
+}
+/**
+ * The runtime endpoint requires every leaf filter to carry the field's
+ * `propertyType` (int) alongside propertyCode/propertyValue/queryFilterType;
+ * without it the query fails with errcode 10009 类型转换异常. The value must
+ * come from field metadata — never guessed (cpdocs filter-condition contract).
+ */
+export function injectPropertyTypes(condition, resolve) {
+    const missing = new Set();
+    const walk = (node) => {
+        if (Array.isArray(node))
+            return node.map(walk);
+        const leaf = node;
+        const code = String(leaf?.propertyCode ?? "");
+        const type = resolve(code);
+        if (type === undefined) {
+            missing.add(code);
+            return leaf;
+        }
+        return { ...leaf, propertyType: type };
+    };
+    const walked = walk(condition);
+    return missing.size > 0 ? { ok: false, missing: [...missing].sort() } : { ok: true, condition: walked };
+}
+//# sourceMappingURL=data-list-filter.js.map