@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/src/cmp/java/TestDirect_java.ts

@@ -15,6 +15,8 @@ import {
   serverVarEnv,
   serverVariables, envName, envToken,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -181,6 +183,15 @@ import ${javapackage}.utility.Json;
 @SuppressWarnings({"unchecked", "unused"})
 public class ${entity.Name}DirectTest {
 
+${liveStrictNote(liveStrict(model, target.name), '//', '  ')}
+  static final boolean LIVE_STRICT = ${liveStrict(model, target.name)};
+
+  static boolean liveOk(Map<String, Object> result) {
+    int status = Helpers.toInt(result.get("status"));
+    return result.get("err") == null && Boolean.TRUE.equals(result.get("ok"))
+        && status >= 200 && status < 300;
+  }
+
   static Map<String, Object> jm(Object... kv) {
     Map<String, Object> out = new LinkedHashMap<>();
     for (int i = 0; i < kv.length - 1; i += 2) {
@@ -207,8 +218,9 @@ public class ${entity.Name}DirectTest {
       const listSkipBlock = listLiveIdKeys.length > 0
         ? `    if (setup.live) {
       for (String liveKey : new String[] { ${listLiveIdKeys.map((k: string) => `"${k}"`).join(', ')} }) {
-        Assumptions.assumeTrue(setup.idmap.get(liveKey) != null,
-            "live test needs " + liveKey + " via *_ENTID env var (synthetic IDs only)");
+        if (setup.idmap.get(liveKey) == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live test blocked: needs " + liveKey + " via ${entidEnvVar}");
+        }
       }
     }
 `
@@ -258,14 +270,12 @@ ${listSkipBlock}    ${SDK} client = setup.client;
       }
 
       Content(`    if (setup.live) {
-      // Live mode is lenient: synthetic IDs frequently 4xx and the
-      // list-response shape varies wildly across public APIs. Skip
-      // rather than fail when the call doesn't return a usable list.
-      Assumptions.assumeTrue(Boolean.TRUE.equals(result.get("ok")),
-          "list call not ok (likely synthetic IDs against live API): " + result);
-      int status = Helpers.toInt(result.get("status"));
-      Assumptions.assumeTrue(status >= 200 && status < 300,
-          "expected 2xx status, got " + result.get("status"));
+      if (!liveOk(result)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list failed: " + RunnerSupport.liveDescribe(result));
+      }
+      if (RunnerSupport.liveList(result.get("data")) == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list returned no list: " + RunnerSupport.liveDescribe(result));
+      }
     }
     else {
       assertEquals(true, result.get("ok"), "expected ok to be true");
@@ -306,23 +316,18 @@ ${listSkipBlock}    ${SDK} client = setup.client;
       // Identify ancestor params (not 'id') for live mode
       const ancestorParams = loadParams.filter((p: any) => p.n !== 'id')
 
+      const liveKey = (p: any) => p.n === 'id' ? entity.name + '01' : p.n.replace(/_id$/, '') + '01'
       let loadLiveIdKeys: string[] = []
       if (loadParams.length > 0 && !loadAllHaveExamples) {
-        if (hasList) {
-          loadLiveIdKeys = listParams.map((p: any) => {
-            return p.n === 'id'
-              ? entity.name + '01'
-              : p.n.replace(/_id$/, '') + '01'
-          })
-        } else {
-          loadLiveIdKeys = loadParams.map((p: any) => p.n + '01')
-        }
+        loadLiveIdKeys = [...new Set((hasList ?
+          [...listParams, ...loadParams.filter((p: any) => p.n !== 'id')] : loadParams).map(liveKey))]
       }
       const loadSkipBlock = loadLiveIdKeys.length > 0
         ? `    if (setup.live) {
       for (String liveKey : new String[] { ${loadLiveIdKeys.map(k => `"${k}"`).join(', ')} }) {
-        Assumptions.assumeTrue(setup.idmap.get(liveKey) != null,
-            "live test needs " + liveKey + " via *_ENTID env var (synthetic IDs only)");
+        if (setup.idmap.get(liveKey) == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live test blocked: needs " + liveKey + " via ${entidEnvVar}");
+        }
       }
     }
 `
@@ -370,19 +375,30 @@ ${loadSkipBlock}    ${SDK} client = setup.client;
           "path", "${listPath}",
           "method", "GET",
           "params", listParams));
-      Assumptions.assumeTrue(Boolean.TRUE.equals(listResult.get("ok")),
-          "list call not ok (likely synthetic IDs against live API): " + listResult);
-
-      // Get first entity ID from list
-      List<Object> listData = listResult.get("data") instanceof List
-          ? (List<Object>) listResult.get("data") : new ArrayList<>();
-      Assumptions.assumeTrue(!listData.isEmpty(), "no entities to load in live mode");
+      if (!liveOk(listResult)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list discovery failed: " + RunnerSupport.liveDescribe(listResult));
+      }
+      List<Object> listData = RunnerSupport.liveList(listResult.get("data"));
+      if (listData == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list discovery returned no list: " + RunnerSupport.liveDescribe(listResult));
+      }
+      if (listData.isEmpty()) {
+        RunnerSupport.liveEmpty("The account has no ${entity.name} record to load");
+      }
       Map<String, Object> firstEnt = Helpers.toMapAny(listData.get(0));
+      if (firstEnt == null || firstEnt.get("id") == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live load blocked: discovery returned no usable identity");
+      }
       params.put("id", firstEnt.get("id"));
 `)
           for (const p of ancestorParams) {
             const key = p.n.replace(/_id$/, '') + '01'
             Content(`      params.put("${p.n}", setup.idmap.get("${key}"));
+`)
+          }
+        } else if (loadParams.length > 0) {
+          for (const p of loadParams) {
+            Content(`      params.put("${p.n}", setup.idmap.get("${liveKey(p)}"));
 `)
           }
         }
@@ -418,14 +434,12 @@ ${loadSkipBlock}    ${SDK} client = setup.client;
       }
 
       Content(`    if (setup.live) {
-      // Live mode is lenient: synthetic IDs frequently 4xx. Skip rather
-      // than fail when the load endpoint isn't reachable with the IDs we
-      // can construct from setup.idmap.
-      Assumptions.assumeTrue(Boolean.TRUE.equals(result.get("ok")),
-          "load call not ok (likely synthetic IDs against live API): " + result);
-      int status = Helpers.toInt(result.get("status"));
-      Assumptions.assumeTrue(status >= 200 && status < 300,
-          "expected 2xx status, got " + result.get("status"));
+      if (!liveOk(result)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live load failed: " + RunnerSupport.liveDescribe(result));
+      }
+      if (result.get("data") == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live load returned no data: " + RunnerSupport.liveDescribe(result));
+      }
     }
     else {
       assertEquals(true, result.get("ok"), "expected ok to be true");

package/project/.sdk/src/cmp/java/TestEntity_java.ts

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable, invalidRequest } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -20,7 +20,8 @@ import {
   getMatchEntries,
   isAuthActive,
   serverVarEnv,
-  serverVariables, envName, envToken
+  serverVariables, envName, envToken,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -47,6 +48,50 @@ type GenCtx = {
 type OpGen = (ctx: GenCtx, step: ModelEntityFlowStep, index: number) => void
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, a create-less load reading the first listed record, and
+// a lenient run observing its checks rather than failing on them.
+function liveFlowGate(entity: any, needs: any, entidEnv: string, accessor: string,
+  SDK: string, strict: boolean, hasSteps: boolean): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `    if (setup.live) {
+      for (String liveKey : new String[] { ${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')} }) {
+        if (setup.syntheticOnly || setup.idmap.get(liveKey) == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live entity test blocked: needs " + liveKey + " via ${entidEnv}");
+        }
+      }
+    }
+`
+  }
+  if (null != needs.blocked) {
+    out += `    if (setup.live) {
+      RunnerSupport.liveMiss(LIVE_STRICT, "Live entity test blocked: " + ${JSON.stringify(needs.blocked)});
+    }
+`
+  }
+  if (!hasSteps) {
+    return out
+  }
+  out += `    ${SDK} client = setup.client;\n`
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `match.put(${JSON.stringify(k)}, setup.idmap.get(${JSON.stringify(v)}));`).join(' ')
+    out += `    if (setup.live) {
+      RunnerSupport.liveExisting(setup.data, LIVE_STRICT, ${JSON.stringify(entity.name)}, () -> {
+        Map<String, Object> match = new LinkedHashMap<>();${match ? ' ' + match : ''}
+        return client.${accessor}(null).list(match, null);
+      });
+    }
+`
+  }
+  if (!strict) {
+    out += '    try {\n'
+  }
+  return out + '\n'
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
@@ -96,6 +141,9 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, javapackage, flow: basicflow, PROJUPPER, accessor }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+
   const stepOps = Array.from(new Set(
     (allSteps as any[]).map((s: any) => s.o).filter(Boolean)))
 
@@ -106,6 +154,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.nio.file.Files;
@@ -119,15 +168,22 @@ import java.util.stream.Collectors;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
 
+import ${javapackage}.core.Config;
+import ${javapackage}.core.Context;
 import ${javapackage}.core.Helpers;
 import ${javapackage}.core.SdkEntity;
+import ${javapackage}.core.SdkError;
 import ${javapackage}.core.${SDK};
+import ${javapackage}.feature.BaseFeature;
 import ${javapackage}.utility.Json;
 import ${javapackage}.utility.struct.Struct;
 
 @SuppressWarnings({"unchecked", "unused"})
 public class ${entity.Name}EntityTest {
 
+${liveStrictNote(strict, '//', '  ')}
+  static final boolean LIVE_STRICT = ${strict};
+
   @Test
   public void instance() {
     ${SDK} testsdk = ${SDK}.testSDK();
@@ -147,11 +203,7 @@ public class ${entity.Name}EntityTest {
           reason == null || "".equals(reason)
               ? "skipped via sdk-test-control.json" : reason);
     }
-    // The basic flow consumes synthetic IDs from the fixture. In live mode
-    // without an *_ENTID env override, those IDs hit the live API and 4xx.
-    Assumptions.assumeFalse(setup.syntheticOnly,
-        "live entity test uses synthetic IDs from fixture — set ${entidEnvVar} JSON to run live");
-${allSteps.length > 0 ? `    ${SDK} client = setup.client;\n\n` : ''}`)
+${liveFlowGate(entity, needs, entidEnvVar, accessor, SDK, strict, allSteps.length > 0)}`)
 
     // Check if the flow has a create step; if not, bootstrap entity data
     const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
@@ -176,11 +228,17 @@ ${allSteps.length > 0 ? `    ${SDK} client = setup.client;\n\n` : ''}`)
       }
     })
 
-    Content(`  }
+    Content(`${strict || 0 === allSteps.length ? '' : `    }
+    catch (Throwable err) {
+      RunnerSupport.liveObserve(err, setup.live, LIVE_STRICT);
+    }
+`}  }
 
 `)
 
-    const flowHasList = allSteps.some((s: any) => s.o === 'list')
+    // The stream test lists with no match, so a bare call must reach a route.
+    const flowHasList = allSteps.some((s: any) => s.o === 'list') &&
+      opReachable((entity.op as any)?.list, [])
     if (flowHasList) {
       Content(`  @Test
   public void stream() {
@@ -223,6 +281,9 @@ ${allSteps.length > 0 ? `    ${SDK} client = setup.client;\n\n` : ''}`)
 `)
     }
 
+    const hasList = opReachable((entity.op as any)?.list, [])
+    Content(failureTests(SDK, entity, accessor, hasList))
+
     // Generate setup function
     Content(`  static RunnerSupport.EntityTestSetup ${accessor}BasicSetup(Map<String, Object> extra) {
     RunnerSupport.loadEnvLocal();
@@ -257,10 +318,8 @@ ${allSteps.length > 0 ? `    ${SDK} client = setup.client;\n\n` : ''}`)
         + "\\"\`$VAL\`\\": [\\"\`$FORMAT\`\\", \\"upper\\", \\"\`$COPY\`\\"]"
         + "}]}"));
 
-    // Detect ENTID env override before envOverride consumes it. When live
-    // mode is on without a real override, the basic test runs against
-    // synthetic IDs from the fixture and 4xx's. Surface this so the test
-    // can skip.
+    // Whether *_ENTID supplied the idmap, read before envOverride consumes
+    // it: without it, the ids a live flow binds are the fixture's synthetic ones.
     String entidEnvRaw = RunnerSupport.getenv("${entidEnvVar}");
     boolean idmapOverridden = entidEnvRaw != null
         && entidEnvRaw.trim().startsWith("{");
@@ -616,6 +675,114 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation throws from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A throwing hook fires
+// PreUnexpected, under throw false too. The caller's ctrl stays its own. An
+// invalid request fails with validate's own error, before it is sent.
+function failureTests(SDK: string, entity: ModelEntity, accessor: string, hasList: boolean): string {
+  const bad = invalidRequest(entity)
+  if (!hasList && null == bad) {
+    return ''
+  }
+
+  let out = `  static boolean hasFeature(String name) {
+    Map<String, Object> fm = Helpers.toMapAny(Config.makeConfig().get("feature"));
+    return fm != null && fm.get(name) != null;
+  }
+
+`
+
+  if (hasList) {
+    out += `  public static final class FailHook extends BaseFeature {
+    int unexpected = 0;
+
+    FailHook() {
+      super("failhook", "0.0.1", true);
+    }
+
+    @Override
+    public void preSpec(Context ctx) {
+      throw new RuntimeException("${entity.name} hook failed");
+    }
+
+    @Override
+    public void preUnexpected(Context ctx) {
+      this.unexpected++;
+    }
+  }
+
+  @Test
+  public void streamError() {
+    Map<String, Object> offline = Struct.jm("net", Struct.jm("offline", true));
+    RuntimeException err = assertThrows(RuntimeException.class, () ->
+        ${SDK}.testSDK(offline, null).${accessor}(null).stream("list", null, null)
+            .collect(Collectors.toList()));
+    assertTrue(err.getMessage().contains("offline"), err.getMessage());
+
+    ${SDK}.testSDK(offline, null).${accessor}(null)
+        .stream("list", null, Struct.jm("ctrl", Struct.jm("throw", false)))
+        .collect(Collectors.toList());
+
+    if (hasFeature("rbac")) {
+      ${SDK} denied = ${SDK}.testSDK(null,
+          Struct.jm("feature", Struct.jm("rbac", Struct.jm("active", true, "deny", true))));
+      SdkError denyerr = assertThrows(SdkError.class, () ->
+          denied.${accessor}(null).stream("list", null, null).collect(Collectors.toList()));
+      assertEquals("rbac_denied", denyerr.code);
+    }
+  }
+
+  @Test
+  public void streamCtrl() {
+    Map<String, Object> explain = new LinkedHashMap<>();
+    Map<String, Object> ctrl = new LinkedHashMap<>();
+    ctrl.put("explain", explain);
+    ${SDK}.testSDK().${accessor}(null).stream("list", null, Struct.jm("ctrl", ctrl))
+        .collect(Collectors.toList());
+    assertEquals(List.of("explain"), new ArrayList<>(ctrl.keySet()));
+    assertTrue(explain == ctrl.get("explain") && !explain.isEmpty());
+  }
+
+  @Test
+  public void unexpected() {
+    FailHook hook = new FailHook();
+    ${SDK} client = new ${SDK}(Struct.jm(
+        "feature", Struct.jm("test", Struct.jm("active", true)),
+        "extend", Struct.jt(hook)));
+
+    RuntimeException err = assertThrows(RuntimeException.class, () ->
+        client.${accessor}(null).list(null, null));
+    assertTrue(err.getMessage().contains("hook failed"), err.getMessage());
+    assertTrue(0 < hook.unexpected);
+
+    int fired = hook.unexpected;
+    client.${accessor}(null).list(null, Struct.jm("throw", false));
+    assertTrue(fired < hook.unexpected);
+  }
+
+`
+  }
+
+  if (null != bad) {
+    const args = Object.entries(bad.args)
+      .map(([k, v]) => JSON.stringify(k) + ', ' + JSON.stringify(v)).join(', ')
+    out += `  @Test
+  public void validate() {
+    Assumptions.assumeTrue(hasFeature("validate"), "feature not present in this SDK: validate");
+    ${SDK} client = ${SDK}.testSDK(null,
+        Struct.jm("feature", Struct.jm("validate", Struct.jm("active", true))));
+    SdkError err = assertThrows(SdkError.class, () ->
+        client.${accessor}(null).${bad.op}(Struct.jm(${args}), null));
+    assertEquals("validate_failed", err.code);
+  }
+
+`
+  }
+
+  return out
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/java/fragment/Entity.fragment.java

@@ -31,5 +31,7 @@ public class EntyClass extends EntityBase {
 
 // #UpdateOp
 
+// #PatchOp
+
 // #RemoveOp
 }

package/project/.sdk/src/cmp/java/fragment/EntityBase.fragment.java

@@ -214,9 +214,11 @@ public abstract class EntityBase implements SdkEntity {
     final BooleanSupplier signal =
         signalObj instanceof BooleanSupplier ? (BooleanSupplier) signalObj : null;
 
-    Map<String, Object> ctrl = Helpers.toMapAny(callopts.get("ctrl"));
-    if (ctrl == null) {
-      ctrl = new LinkedHashMap<>();
+    // A copy: the caller's ctrl gains no key, and explain stays its own record.
+    Map<String, Object> ctrl = new LinkedHashMap<>();
+    Map<String, Object> callerCtrl = Helpers.toMapAny(callopts.get("ctrl"));
+    if (callerCtrl != null) {
+      ctrl.putAll(callerCtrl);
     }
     ctrl.put("stream", callopts);
 

package/project/.sdk/src/cmp/java/fragment/EntityPatchOp.fragment.java

@@ -0,0 +1,45 @@
+package JAVAPACKAGE.entity;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import JAVAPACKAGE.core.Context;
+import JAVAPACKAGE.core.Helpers;
+import JAVAPACKAGE.core.SdkClient;
+import JAVAPACKAGE.utility.struct.Struct;
+
+// Fragment carrier: only the section between the EJECT markers is spliced
+// into the generated entity class (which extends EntityBase).
+abstract class EntityPatchOpFragment extends EntityBase {
+
+  EntityPatchOpFragment(SdkClient client, Map<String, Object> entopts) {
+    super("entityname", client, entopts);
+  }
+
+// EJECT-START
+
+  @Override
+  public Object patch(Map<String, Object> reqdata, Map<String, Object> ctrl) {
+    Map<String, Object> ctxmap = new LinkedHashMap<>();
+    ctxmap.put("opname", "patch");
+    ctxmap.put("ctrl", ctrl);
+    ctxmap.put("match", this.match);
+    ctxmap.put("data", this.data);
+    ctxmap.put("reqdata", reqdata);
+    Context ctx = this.utility.makeContext.apply(ctxmap, this.entctx);
+
+    return runOp(ctx, () -> {
+      if (ctx.result != null) {
+        if (ctx.result.resmatch != null) {
+          this.match = ctx.result.resmatch;
+        }
+        if (ctx.result.resdata != null) {
+          Map<String, Object> d = Helpers.toMapAny(Struct.clone(ctx.result.resdata));
+          this.data = d == null ? new LinkedHashMap<>() : d;
+        }
+      }
+    });
+  }
+
+// EJECT-END
+}

package/project/.sdk/src/cmp/js/EntityTypes_js.ts

@@ -68,7 +68,7 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 `)
 
       const ops = ent.op || {}
-      ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+      ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
         if (null == ops[opname]) {
           return
         }

package/project/.sdk/src/cmp/js/Entity_js.ts

@@ -40,7 +40,7 @@ const Entity = cmp(function Entity(props: any) {
       const opnames = Object.keys(entity.op || {})
 
       const opfrags =
-        (['load', 'list', 'create', 'update', 'remove']
+        (['load', 'list', 'create', 'update', 'patch', 'remove']
           .reduce((a: any, opname: string) =>
           (a['#' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ? '' : ({ indent }: any) => {

package/project/.sdk/src/cmp/js/Main_js.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  inactiveFeatureExcludes,
   entityClassName, entityCollection, srcFeatureExcludes, pluginExcludes,
   stationLibrary,
   targetFeatures,
@@ -57,6 +58,7 @@ const Main = cmp(async function Main(props: any) {
     from: 'tm/' + target.name,
     exclude: [
       ...srcFeatureExcludes(model),
+      ...inactiveFeatureExcludes(props.ctx$, target),
       ...pluginExcludes(model),
       TEST_CONTROL_EXCLUDE,
     ],

package/project/.sdk/src/cmp/js/Package_js.ts

@@ -15,6 +15,9 @@ import {
   authorInfo,
   targetFeatures, envName,
   hasLiveScenarios,
+  npmScriptRm,
+  npmScriptEnv,
+  npmScriptTestSome,
 } from '@voxgig/sdkgen'
 
 
@@ -74,19 +77,19 @@ const Package = cmp(async function Package(props: any) {
 
     // What actually ships. Without `files`, `npm publish` packs the test
     // suite and the build scaffolding too. The js target runs from `src`
-    // directly (no build step), so that and the README are the whole package.
-    files: ['src', 'README.md'],
+    // directly (no build step), so that and the docs are the whole package.
+    files: ['src', 'README.md', 'REFERENCE.md'],
     scripts: {
       ...(hasLiveScenarios(model) ? {
-        'test:live': `${envName(model)}_TEST_LIVE=TRUE node --test test/live.test.js`,
+        'test:live': 'node ' + npmScriptEnv(envName(model) + '_TEST_LIVE', 'TRUE') +
+          ' --test test/live.test.js',
       } : {}),
 
-      'test': 'node --test \'test/**/*.test.js\'',
-      'test-some': 'node --experimental-test-isolation=none ' +
-        '--test-name-pattern=\"$TEST_PATTERN\" --test \'test/**/*.test.js\'',
-      'test-utility': 'node --test test/utility/*.test.js',
+      'test': 'node --test "test/**/*.test.js"',
+      'test-some': npmScriptTestSome(['--experimental-test-isolation=none'], 'test/**/*.test.js'),
+      'test-utility': 'node --test "test/utility/*.test.js"',
 
-      "clean": "rm -rf node_modules yarn.lock package-lock.json",
+      "clean": npmScriptRm(['node_modules', 'yarn.lock', 'package-lock.json']),
       "reset": "npm run clean && npm i && npm test",
     },
     author,