@voxgig/sdkgen 4.5.3 → 4.6.0

package/project/.sdk/tm/ts/test/omni.test.ts

@@ -0,0 +1,84 @@
+// Smoke tests for the vendored omni runner itself: a runner that cannot
+// FAIL a bad entry would turn every corpus suite vacuously green, so pin
+// the failure paths, not just the happy one.
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+
+import { SDK } from '..'
+
+import { OmniError, makeRunner } from './omni'
+
+
+// A minimal in-memory spec: no fixture file, no OMNI block (lenient v0,
+// like the shared corpus).
+const SPEC = {
+  primary: {
+    smoke: {
+      basic: {
+        set: [
+          { in: 1, out: 2 },
+          { in: 41, out: 42 },
+        ],
+      },
+      bad: {
+        set: [
+          { in: 1, out: 999 },
+        ],
+      },
+      err: {
+        set: [
+          { in: 0, err: 'zero refused' },
+        ],
+      },
+    },
+  },
+}
+
+const inc = (n: number) => {
+  if (0 === n) {
+    throw new Error('smoke: zero refused')
+  }
+  return n + 1
+}
+
+
+describe('omni', () => {
+
+  test('runset passes a correct subject', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R: any = await runner('smoke')
+    await R.runset(R.spec.basic, inc)
+  })
+
+
+  test('runset FAILS a wrong result, with OmniError', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R: any = await runner('smoke')
+    await assert.rejects(
+      () => R.runset(R.spec.bad, inc),
+      (err: any) => {
+        assert.equal(err.name, 'OmniError')
+        assert.ok(err instanceof OmniError)
+        assert.match(err.message, /result mismatch/)
+        return true
+      })
+  })
+
+
+  test('an expected error is matched, an unexpected one fails', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R: any = await runner('smoke')
+
+    await R.runset(R.spec.err, inc)
+
+    await assert.rejects(
+      () => R.runset(R.spec.err, (n: number) => n),
+      (err: any) => {
+        assert.equal(err.name, 'OmniError')
+        assert.match(err.message, /expected error did not occur/)
+        return true
+      })
+  })
+
+})

package/project/.sdk/tm/ts/test/omni.ts

@@ -0,0 +1,86 @@
+// The corpus test runner: vendored @voxgig/omni behind the struct-runner
+// API the corpus tests already use (`import { makeRunner } from '../omni'`
+// instead of the old hand-vendored '../runner').
+//
+// Two local decisions, both required (see vendor/omni/compat.ts):
+//
+// 1. SPEC PATH. The compat shim's caller-directory heuristic resolves a
+//    relative test-file path one level too deep for this layout (loader in
+//    dist-test/, test files in dist-test/utility/) - its own header says a
+//    port must resolve the path itself. This module compiles to
+//    dist-test/omni.js, the same depth as the old dist-test/runner.js, so
+//    the existing TEST_JSON_FILE constant keeps working verbatim.
+//
+// 2. PROVIDER DELEGATION. Corpus-driven contexts get `ctx.client` set to
+//    the runner's provider. The stock structprovider forwards utility()
+//    and tester() but not options()/_features/_rootctx/_mode, which the
+//    corpus subjects and pipeline utilities (prepareHeaders via
+//    client.options(), test helpers via client._rootctx) do reach. The
+//    provider below is built by PROTOTYPE DELEGATION over the live SDK
+//    instance, so every SDK member resolves while the four omni hooks sit
+//    on top. Upstream omni's compat shim could adopt the same shape.
+
+import { isAbsolute, join } from 'node:path'
+
+import {
+  EXISTSMARK,
+  NULLMARK,
+  UNDEFMARK,
+  nullModifier,
+  structprovider,
+} from './vendor/omni/compat'
+
+import type { StructProvider, StructRunner } from './vendor/omni/compat'
+
+import { OmniError, makeRunner as omnimakerunner } from './vendor/omni/index'
+
+import type { Json } from './vendor/omni/index'
+
+
+// Wrap the SDK as an omni provider WITHOUT hiding it: hooks from the stock
+// structprovider, everything else through the prototype chain.
+function sdkprovider(sdk: any): StructProvider {
+  const hooks = structprovider(sdk)
+  const provider = Object.assign(Object.create(sdk), hooks)
+
+  // DEF.client entries become SDK instances too - rewrap with the same
+  // delegating shape, not the stock one.
+  provider.client = async (options: Json) => sdkprovider(await sdk.tester(options))
+
+  return provider
+}
+
+
+// struct's makeRunner(testfile, client) signature, backed by vendored omni.
+// Also accepts an already-parsed spec object (omni's own capability), which
+// keeps smoke tests free of fixture files.
+async function makeRunner(testfile: string | Json, client: any): Promise<StructRunner> {
+  const specref = 'string' !== typeof testfile ? testfile
+    : isAbsolute(testfile) ? testfile
+      : join(__dirname, testfile)
+
+  const provider = sdkprovider(client)
+  const runner = await omnimakerunner(specref, provider)
+
+  return async function structrunner(name: string, store?: any) {
+    const runpack = await runner(name, store)
+
+    return {
+      spec: runpack.spec,
+      runset: runpack.runset,
+      runsetflags: runpack.runsetflags,
+      subject: runpack.subject,
+      client: provider,
+    }
+  }
+}
+
+
+export {
+  EXISTSMARK,
+  NULLMARK,
+  UNDEFMARK,
+  OmniError,
+  makeRunner,
+  nullModifier,
+}

package/project/.sdk/tm/ts/test/utility/PrimaryUtility.test.ts

@@ -5,7 +5,7 @@ import assert from 'node:assert'
 
 import {
   makeRunner,
-} from '../runner'
+} from '../omni'
 
 import {
   SDK,
@@ -70,7 +70,11 @@ describe('PrimaryUtility', async () => {
     spec = run.spec
     runset = run.runset
     runsetflags = run.runsetflags
-    client = run.client
+    // Under the old hand-vendored runner, run.client WAS the SDK; under
+    // omni it is the provider wrapping it. This suite treats the client as
+    // the SDK — including ASSIGNING to client._features, which prototype
+    // delegation cannot forward — so unwrap the real instance.
+    client = (run.client as any).sdk
     utility = client.utility()
     struct = utility.struct
   })

package/project/.sdk/tm/ts/test/utility/StructUtility.test.ts

@@ -1,4 +1,4 @@
-// VERSION: @voxgig/struct 0.0.10
+// VERSION: @voxgig/struct 0.3.2 (vendored via omni compat; see ../omni.ts)
 // RUN: npm test
 // RUN-SOME: npm run test-some --pattern=getpath
 
@@ -9,7 +9,7 @@ import {
   makeRunner,
   nullModifier,
   NULLMARK,
-} from '../runner'
+} from '../omni'
 
 
 import {

package/project/.sdk/tm/ts/test/utility.ts

@@ -90,6 +90,7 @@ type TestControl = {
       unit?: { direct?: any[], entityOp?: any[] }
     }
     live?: { delayMs?: number }
+    client?: { options?: Record<string, any> }
     [k: string]: any
   }
   [k: string]: any
@@ -167,6 +168,55 @@ function skipIfMissingIds(t: any, setup: any, requiredKeys: string[]): boolean {
 }
 
 
+// Extra SDK options every LIVE client is constructed with, from
+// sdk-test-control.json `test.client.options`.
+//
+// The generated live client knows two things: the base URL (from the spec)
+// and the credential (from the environment). Everything else about how a
+// particular API wants to be talked to — which features to switch on, and
+// with what settings — is a property of THAT API, known to the project and
+// to nothing in the toolchain.
+//
+// The concrete case: an API that issues short-lived access tokens needs the
+// `secrets` feature's exchange turned on and pointed at its token endpoint,
+// or the live suite gets a handful of calls in and then fails 401 with
+// nothing explaining why. There was no seam for that, so the suite could
+// not be run at all.
+//
+// A committed FILE rather than an environment variable, because it is
+// configuration, not a secret: it belongs in the repo next to the API it
+// describes, where it can be read and reviewed. Secrets still come from the
+// environment (the providers this block names read them).
+//
+// Merged UNDER the generated fields, so the suite's own base/apikey/server
+// values win — this adds to the live client, it does not redirect it.
+//
+// That contract is enforced HERE rather than left to each merge site: the
+// generated object only names a field when the model calls for one, so a
+// `base` in this block would face no competing value and would silently
+// redirect the whole suite — credential included — to another host. The
+// reserved fields are stripped once, where the block is read, so every
+// caller gets the same guarantee whether or not it happens to emit them.
+const LIVE_RESERVED = ['base', 'prefix', 'suffix', 'server', 'apikey', 'secret']
+
+function liveClientOptions(): Record<string, any> {
+  const opts = loadTestControl()?.test?.client?.options
+
+  if (null == opts || 'object' !== typeof opts) {
+    return {}
+  }
+
+  const out: Record<string, any> = {}
+  for (const key of Object.keys(opts)) {
+    if (!LIVE_RESERVED.includes(key)) {
+      out[key] = (opts as any)[key]
+    }
+  }
+
+  return out
+}
+
+
 // Per-test live pacing delay (ms). Read from sdk-test-control.json
 // `test.live.delayMs`; defaults to 500ms if absent or invalid.
 function liveDelayMs(): number {
@@ -188,6 +238,76 @@ function liveDelay(liveEnvVar: string): () => Promise<void> {
 }
 
 
+// Load a .env.local file into process.env, replacing the `dotenv`
+// devDependency — the SDK's last non-tooling package.
+//
+// Same semantics dotenv gave these tests: a missing file is fine, and a key
+// already present in the environment is never overridden, so an explicit
+// export still beats the file.
+//
+// WHY NOT sekreto's parsedotenv, which does the same job and is already
+// vendored: sekreto lives INSIDE the secrets feature container, so `target
+// add` removes it whenever a project does not select that feature — while
+// these entity tests need the loader either way. Importing it here would
+// couple every generated test suite to an optional feature. The parser is
+// small enough that a second, independent copy is cheaper than that
+// coupling; it deliberately handles only what a .env.local holds.
+function loadEnvLocal(file: string): void {
+  let text: string
+  try {
+    text = Fs.readFileSync(file, 'utf8')
+  }
+  catch (err: any) {
+    if ('ENOENT' === err.code) {
+      return
+    }
+    throw err
+  }
+
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim()
+
+    // Blank and comment lines. A '#' INSIDE a value is not a comment.
+    if ('' === line || line.startsWith('#')) {
+      continue
+    }
+
+    const eq = line.indexOf('=')
+    if (0 >= eq) {
+      continue
+    }
+
+    const key = line.slice(0, eq).trim().replace(/^export\s+/, '')
+    let val = line.slice(eq + 1).trim()
+
+    const quote = ("'" === val[0] || '"' === val[0]) ? val[0] : ''
+
+    if ('' !== quote) {
+      // Quoted: the value runs to the CLOSING quote, and a '#' inside it is
+      // part of the value. Anything after the closing quote is a comment.
+      const close = val.indexOf(quote, 1)
+      val = 0 < close ? val.slice(1, close) : val.slice(1)
+    }
+    else {
+      // Unquoted: the first '#' starts an inline comment, with or without
+      // preceding whitespace — `A=a#b` is `a` to dotenv, not `a#b`.
+      // Dropping this made `KEY=secret # note` resolve to the whole string
+      // including the note, and a generated live test would then send that
+      // as the credential. Verified against dotenv's own parse().
+      const hash = val.indexOf('#')
+      if (0 <= hash) {
+        val = val.slice(0, hash)
+      }
+      val = val.trim()
+    }
+
+    if (undefined === process.env[key]) {
+      process.env[key] = val
+    }
+  }
+}
+
+
 export {
   makeStepData,
   makeMatch,
@@ -199,6 +319,8 @@ export {
   isControlSkipped,
   maybeSkipControl,
   skipIfMissingIds,
+  liveClientOptions,
   liveDelayMs,
   liveDelay,
+  loadEnvLocal,
 }