biome-plugin-suitescript 0.2.0 → 0.4.0

package/dist/rules/requireOrderByForPagedSuiteQL.js

@@ -0,0 +1,17 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { staticSuiteql } from "../lib/suiteql.js";
+// Oracle (query.runSuiteQLPaged): "You must specify a sorting order in the query
+// definition when using this method to avoid duplicate or missing results. The
+// query definition must provide a unique and unambiguous sorting order with a
+// specified precedence." Only a query built from literals can be checked.
+export const requireOrderByForPagedSuiteQL = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        if (!/(^|\.)runSuiteQLPaged(\.promise)?$/.test(node.callee?.text ?? ""))
+            return;
+        const sql = staticSuiteql(node);
+        if (sql && !/\bORDER\s+BY\b/i.test(sql)) {
+            registerDiagnostic(node, "warning", "A paged SuiteQL query needs an ORDER BY to avoid duplicate or missing results.");
+        }
+    },
+});

package/dist/rules/requireQueryOptions.js

@@ -0,0 +1,53 @@
+import { defineRule, registerDiagnostic, semantic, } from "@biomejs/runtime/plugin";
+import { moduleOfReceiver } from "../lib/module-calls.js";
+import { MODULES } from "../lib/modules.js";
+import { definedOptions } from "../lib/required-options.js";
+// Oracle (N/query, Query.createColumn and createCondition): "options.fieldId:
+// required if options.formula is not used" and "options.type: required if
+// options.formula is used"; createCondition's `operator` is required and
+// createSort's `column` is required. The type definitions (N/query.d.ts) outrank
+// the page and give a formula-only condition its own overload without `operator`,
+// so `operator` is required only when there is no `formula`. They type `type?` as
+// optional with the formula, but their own comment says "Required if options.formula
+// is used", which agrees with the page. Only an options object literal without a
+// spread is checked. A receiver bound to another module is skipped:
+// `search.createColumn({ name })` is N/search, which takes different options. When
+// the binding cannot be resolved, a receiver named like another module's
+// conventional identifier (`search`) is skipped too.
+export const requireQueryOptions = defineRule({
+    query: semantic("JS_CALL_EXPRESSION"),
+    run(node, { model }) {
+        const callee = node.callee?.text ?? "";
+        const method = /(^|\.)(createColumn|createCondition|createSort)$/.exec(callee)?.[2];
+        if (!method)
+            return;
+        const receiver = node.callee?.children()[0];
+        const module = receiver && moduleOfReceiver(receiver, model);
+        if (module && module !== "N/query")
+            return;
+        const conventional = Object.entries(MODULES).find(([, identifier]) => identifier === receiver?.text)?.[0];
+        if (!module && conventional && conventional !== "N/query")
+            return;
+        const defined = definedOptions(node);
+        if (!defined)
+            return;
+        const problems = [];
+        if (method === "createSort") {
+            if (!defined.has("column"))
+                problems.push("needs the 'column' option");
+        }
+        else {
+            if (!defined.has("fieldId") && !defined.has("formula"))
+                problems.push("needs a 'fieldId' or a 'formula' option");
+            if (defined.has("formula") && !defined.has("type"))
+                problems.push("needs the 'type' option when it uses 'formula'");
+            if (method === "createCondition" &&
+                !defined.has("operator") &&
+                !defined.has("formula"))
+                problems.push("needs the 'operator' option");
+        }
+        for (const problem of problems) {
+            registerDiagnostic(node, "error", `${method}() ${problem}.`);
+        }
+    },
+});

package/dist/rules/requireServerResponseOptions.js

@@ -0,0 +1,33 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { definedOptions } from "../lib/required-options.js";
+const REQUIRED = {
+    addHeader: ["name", "value"],
+    getHeader: ["name"],
+    renderPdf: ["xmlString"],
+    sendRedirect: ["type", "identifier"],
+    setHeader: ["name", "value"],
+    write: ["output"],
+    writeFile: ["file"],
+    writeLine: ["output"],
+    writePage: ["pageObject"],
+};
+// Oracle (ServerResponse method pages): each method lists its required options and
+// throws SSS_MISSING_REQD_ARGUMENT without them. The type definitions
+// (N/http.d.ts) require the same options. Only calls on a receiver named
+// like a response, with an options object literal and no spread, are checked.
+export const requireServerResponseOptions = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        const match = /response\.(\w+)$/i.exec(node.callee?.text ?? "");
+        const method = match?.[1];
+        const required = method && REQUIRED[method];
+        const defined = required && definedOptions(node);
+        if (!required || !defined)
+            return;
+        for (const name of required) {
+            if (!defined.has(name)) {
+                registerDiagnostic(node, "error", `${method}() needs the '${name}' option.`);
+            }
+        }
+    },
+});

package/dist/rules/requireServerWidgetOptions.js

@@ -0,0 +1,37 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { definedOptions } from "../lib/required-options.js";
+const LABELLED = ["id", "label"];
+const REQUIRED = {
+    addButton: ["label"],
+    addColumn: [...LABELLED, "type"],
+    addCredentialField: [...LABELLED, "restrictToDomains", "restrictToScriptIds"],
+    addField: [...LABELLED, "type"],
+    addFieldGroup: LABELLED,
+    addSecretKeyField: LABELLED,
+    addSublist: [...LABELLED, "type"],
+    addSubtab: LABELLED,
+    addTab: LABELLED,
+};
+// Oracle (N/ui/serverWidget method pages): each add method lists the options it
+// requires and throws SSS_MISSING_REQD_ARGUMENT without them. The type definitions
+// (N/ui/serverWidget.d.ts) outrank the pages and disagree on two methods: they make
+// addButton's `id` optional and addSecretKeyField's `restrictToScriptIds`
+// optional, where the pages require both, so those two follow the type
+// definitions. The receiver cannot
+// be typed, so a method of the same name on another object can misfire. Only an
+// options object literal without a spread is checked.
+export const requireServerWidgetOptions = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        const method = /\.(\w+)$/.exec(node.callee?.text ?? "")?.[1];
+        const required = method && REQUIRED[method];
+        const defined = required && definedOptions(node);
+        if (!required || !defined)
+            return;
+        for (const name of required) {
+            if (!defined.has(name)) {
+                registerDiagnostic(node, "error", `${method}() needs the '${name}' option.`);
+            }
+        }
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "biome-plugin-suitescript",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Biome lint plugins and a tag checker for NetSuite SuiteScript 2.1, ported from eslint-plugin-suitescript.",
   "keywords": [
     "biome-plugin",
@@ -41,7 +41,15 @@
     "format": "biome check --write",
     "lint": "biome lint",
     "prepack": "npm run build",
+    "readme": "node scripts/rules-table.ts",
+    "skills": "skills",
+    "skills:add": "skills add --skill \"*\" --agent universal --agent claude-code --yes",
+    "skills:check": "skills check",
+    "skills:install": "skills experimental_install && node scripts/link-claude-skills.ts",
+    "skills:list": "skills list",
+    "skills:update": "skills update --project --yes && node scripts/link-claude-skills.ts",
     "sync-modules": "node scripts/sync-modules.ts",
+    "sync-typings": "node scripts/sync-typings.ts",
     "pretest": "npm run build",
     "test": "node --test test/*.test.ts",
     "typecheck": "tsc"
@@ -57,6 +65,7 @@
     "@types/node": "24.19.2",
     "git-pull-run": "2.1.0",
     "lefthook": "2.2.2",
+    "skills": "1.7.6",
     "typescript": "7.0.2"
   },
   "peerDependencies": {

package/dist/rules/noEval.js

@@ -1,21 +0,0 @@
-import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
-const TIMERS = ["setTimeout", "setInterval"];
-// eval(), new Function() and string-form timers run arbitrary code.
-export const noEval = defineRule({
-    query: ast("JS_CALL_EXPRESSION", "JS_NEW_EXPRESSION"),
-    run(node) {
-        const callee = node.callee?.text;
-        if (!callee)
-            return;
-        if (callee === "eval" || callee === "Function") {
-            registerDiagnostic(node, "error", `Do not use ${callee}().`);
-        }
-        else if (node.kind === "JS_CALL_EXPRESSION" && TIMERS.includes(callee)) {
-            const first = node.arguments?.children()[0]?.children()[0];
-            if (first?.kind === "JS_STRING_LITERAL_EXPRESSION" ||
-                first?.kind === "JS_TEMPLATE_EXPRESSION") {
-                registerDiagnostic(node, "error", `Do not pass a string to ${callee}(); it is evaluated as code.`);
-            }
-        }
-    },
-});

package/dist/rules/noExtraModules.js

@@ -1,23 +0,0 @@
-import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
-import { parseDefine } from "../lib/define.js";
-export const noExtraModules = defineRule({
-    query: ast("JS_CALL_EXPRESSION"),
-    run(node) {
-        const def = parseDefine(node);
-        if (!def)
-            return;
-        const names = def.elements;
-        const params = def.params;
-        if (names.length > params.length) {
-            for (const extra of names.slice(params.length)) {
-                registerDiagnostic(extra, "error", `Excess module name ${extra.text}.`);
-            }
-        }
-        else if (params.length > names.length) {
-            for (const extra of params.slice(names.length)) {
-                if (extra)
-                    registerDiagnostic(extra, "error", `Excess module identifier '${extra.text}'.`);
-            }
-        }
-    },
-});

package/dist/rules/noUserEventContextSave.js

@@ -1,12 +0,0 @@
-import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
-// Oracle: "You can't use record.Record.save() here" for the newRecord and
-// oldRecord of a user event context; load the record to change it instead.
-export const noUserEventContextSave = defineRule({
-    query: ast("JS_CALL_EXPRESSION"),
-    run(node) {
-        const callee = node.callee?.text ?? "";
-        if (/(^|\.)(newRecord|oldRecord)\.save$/.test(callee)) {
-            registerDiagnostic(node, "error", `${callee}() is not allowed; the context record is read-only.`);
-        }
-    },
-});