knodin 0.13.1 → 0.14.0

package/dist/src/engine/apex-entry-points.js

@@ -35,9 +35,26 @@ function callbackSignature(contract, declaration) {
     }
     return false;
 }
+const contractNames = new Map([
+    ["queueable", "Queueable"],
+    ["system.queueable", "System.Queueable"],
+    ["database.batchable", "Database.Batchable"],
+    ["schedulable", "Schedulable"],
+    ["system.schedulable", "System.Schedulable"],
+    ["messaging.inboundemailhandler", "Messaging.InboundEmailHandler"],
+]);
+const contractName = (name) => contractNames.get(normalized(name)) ?? name;
 /** Static org-facing declarations, never a claim that an org actually invokes them. */
-export function apexOrgEntryPoints(rows) {
+export function apexPlatformEntryPoints(rows) {
     const protectedSymbols = new Map();
+    const protect = (key, reason, contracts, owner) => {
+        const previous = protectedSymbols.get(key);
+        protectedSymbols.set(key, {
+            reason,
+            contracts: [...new Set([...(previous?.contracts ?? []), ...contracts])],
+            ...(owner ? { ownerKey: owner } : {}),
+        });
+    };
     const classes = new Map();
     for (const row of rows) {
         const decl = row.declaration;
@@ -46,9 +63,9 @@ export function apexOrgEntryPoints(rows) {
         const key = ownerKey(row);
         classes.set(key, [...(classes.get(key) ?? []), row]);
         if (decl.annotations.some((name) => normalized(name) === "restresource"))
-            protectedSymbols.set(row.key, "REST resource declaration");
+            protect(row.key, "REST resource declaration", ["@RestResource"]);
         if (decl.implements.some((name) => callbacks.has(normalized(name))))
-            protectedSymbols.set(row.key, "Salesforce platform callback contract");
+            protect(row.key, "Salesforce platform callback contract", decl.implements.filter((name) => callbacks.has(normalized(name))).map(contractName));
     }
     for (const row of rows) {
         const decl = row.declaration;
@@ -62,6 +79,15 @@ export function apexOrgEntryPoints(rows) {
         const annotations = new Set(decl.annotations.map(normalized));
         const modifiers = new Set(decl.modifiers.map(normalized));
         let reason;
+        const contracts = [];
+        if (annotations.has("invocablemethod") && decl.static)
+            contracts.push("@InvocableMethod");
+        if (annotations.has("auraenabled") && decl.static)
+            contracts.push("@AuraEnabled");
+        if (annotations.has("future") && decl.static)
+            contracts.push("@future");
+        if (modifiers.has("webservice") && decl.static)
+            contracts.push("webservice");
         if (annotations.has("invocablemethod") && decl.static)
             reason = "Invocable Apex declaration";
         if (annotations.has("auraenabled") && decl.static)
@@ -72,15 +98,21 @@ export function apexOrgEntryPoints(rows) {
             reason = "SOAP Apex declaration";
         if (decl.static &&
             owner.declaration.annotations.some((name) => normalized(name) === "restresource") &&
-            ["httpget", "httppost", "httpput", "httppatch", "httpdelete"].some((name) => annotations.has(name)))
+            ["httpget", "httppost", "httpput", "httppatch", "httpdelete"].some((name) => annotations.has(name))) {
             reason = "REST Apex method declaration";
+            contracts.push("@RestResource");
+        }
         if (!decl.static &&
             (modifiers.has("public") || modifiers.has("global")) &&
-            owner.declaration.implements.some((name) => callbackSignature(normalized(name), decl)))
+            owner.declaration.implements.some((name) => callbackSignature(normalized(name), decl))) {
             reason = "Salesforce platform callback method";
+            contracts.push(...owner.declaration.implements
+                .filter((name) => callbackSignature(normalized(name), decl))
+                .map(contractName));
+        }
         if (reason) {
-            protectedSymbols.set(row.key, reason);
-            protectedSymbols.set(owner.key, "Owner of an org-facing Apex declaration");
+            protect(row.key, reason, contracts, owner.key);
+            protect(owner.key, "Owner of an org-facing Apex declaration", contracts);
         }
     }
     // A constructor of an org-facing class is a boundary, not an ordinary helper.
@@ -92,7 +124,11 @@ export function apexOrgEntryPoints(rows) {
         if (owners.length === 1 &&
             protectedSymbols.has(owners[0].key) &&
             normalized(decl.name) === normalized(owners[0].declaration.name))
-            protectedSymbols.set(row.key, "Constructor of an org-facing Apex class");
+            protect(row.key, "Constructor of an org-facing Apex class", protectedSymbols.get(owners[0].key)?.contracts ?? [], owners[0].key);
     }
     return protectedSymbols;
 }
+/** Compatibility projection used by dead-code exclusion; reasons retain their original precedence. */
+export function apexOrgEntryPoints(rows) {
+    return new Map([...apexPlatformEntryPoints(rows)].map(([key, entry]) => [key, entry.reason]));
+}