@voxgig/sdkgen 4.19.1 → 4.20.0

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

@@ -14,6 +14,8 @@ import {
   indent,
   isAuthActive,
   isConfigData,
+  resolveAuthIn,
+  resolveAuthName,
   resolveAuthPrefix,
   serverVariables,
   targetFeatures,
@@ -52,9 +54,18 @@ const Config = cmp(async function Config(props: any) {
   const authActive = isAuthActive(model)
   // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
   const authPrefix = resolveAuthPrefix(model)
+  // `in` and `name` travel with the prefix now. They were resolved by
+  // apidef all along and dropped here, so an apiKey-in-query API got an
+  // Authorization header it does not read. Emitted only when they differ
+  // from the defaults, so a header/Authorization SDK is byte-identical to
+  // what it generated before.
+  const authIn = resolveAuthIn(model)
+  const authName = resolveAuthName(model)
   const authBlock = authActive
     ? `auth: {
-      prefix: '${authPrefix}',
+      prefix: '${authPrefix}',${'header' === authIn ? '' : `
+      in: '${authIn}',`}${'Authorization' === authName ? '' : `
+      name: '${authName}',`}
     },
 
     `

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

@@ -28,6 +28,7 @@ import { Schema } from './Schema_js'
 import { Gitignore } from './Gitignore_js'
 import { MainEntity } from './MainEntity_js'
 import { SdkError } from './SdkError_js'
+import { PrepareAuth } from './PrepareAuth_js'
 import { EntityBase } from './EntityBase_js'
 import { EntityTypes } from './EntityTypes_js'
 
@@ -194,6 +195,11 @@ if (fres instanceof Promise) { await fres }
     })
 
     Config({ target })
+
+    // GENERATED, NOT COPIED. Where the credential goes is a fact about the
+    // API, and tm/ can only hold one answer. See PrepareAuth_js.
+    PrepareAuth({ target })
+
     Schema({ target })
 
     EntityBase({ target })

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

@@ -0,0 +1,244 @@
+
+import {
+  Content,
+  File,
+  Folder,
+  cmp,
+  isHttpBasicAuth,
+  resolveAuthIn,
+  resolveAuthName,
+  resolveAuthPrefix,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
+// rather than templated.
+//
+// This was a static file at `tm/js/src/utility/PrepareAuthUtility.js` that
+// hardcoded `authorization` and a header. apidef has always resolved the
+// scheme's `in` and `name` into `main.kit.info.security` — joplin's says
+// `in: "query", name: "token"` — and generation dropped both. The result
+// was an SDK that sent a header the API does not read and never sent the
+// query parameter it does, so it could not authenticate at all. Four
+// repos in the cedar fleet shipped that way: joplin (`token`), pipedrive
+// (`api_token`), trello (`key`), lm-umbrella (`apiKey`).
+//
+// A template cannot fix this, because the three placements need three
+// different bodies and a template has to pick one. A component emits the
+// branch this API actually uses and nothing else — no dead query code in
+// a bearer-token SDK, and no runtime `if` on a value that is fixed at
+// generation time.
+//
+// Ported from PrepareAuth_ts, which is the proven shape. The differences
+// are the language's, not the design's: no type import, `module.exports`
+// instead of `export {}`, and the prefix read inline off `options.auth`
+// exactly as the js template read it, rather than hoisted into a local
+// that the query and cookie bodies would leave unused.
+const PrepareAuth = cmp(async function PrepareAuth(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+  const active = isAuthActive_js(model)
+  const where = resolveAuthIn(model)
+  // LOWERCASED FOR A HEADER, VERBATIM OTHERWISE. The js runtime keys its
+  // header map in lower case — the old template hardcoded 'authorization',
+  // the shared corpus asserts ctx:spec:headers:authorization, and every
+  // generatedcompile probe reads the lower-case key. apidef writes
+  // name: "Authorization", so emitting it verbatim hides the credential
+  // under a key nothing reads. Query parameters and cookies ARE
+  // case-sensitive and keep the spec's spelling.
+  const resolvedName = resolveAuthName(model)
+  const name = 'header' === where ? resolvedName.toLowerCase() : resolvedName
+  const prefix = resolveAuthPrefix(model)
+  const basic = isHttpBasicAuth(model)
+
+  // No `src` folder here: Main_js already opened it, and Config, Schema,
+  // SdkError, EntityBase and EntityTypes all write straight into it. The
+  // template this replaces lived at `tm/js/src/utility/`, so relative to
+  // that open folder the file needs `utility` and nothing more. Opening a
+  // second `src` would put it at src/src/utility/ — where nothing imports
+  // it, and the stale copy at src/utility/ keeps being used.
+  Folder({ name: 'utility' }, () => {
+    File({ name: 'PrepareAuthUtility.' + target.ext }, () => {
+      Content(render({ active, where, name, prefix, basic }))
+    })
+  })
+})
+
+
+function render(spec: {
+  active: boolean, where: string, name: string, prefix: string, basic: boolean
+}): string {
+
+  // NO AUTH AT ALL. A public API's SDK gets a prepareAuth that is honest
+  // about it rather than one that deletes a header nobody set.
+  if (!spec.active) {
+    return `
+// This API declares no authentication, so there is no credential to
+// place. The function stays in the pipeline because makeSpec calls it
+// unconditionally.
+function prepareAuth(ctx) {
+  const spec = ctx.spec
+
+  if (null == spec) {
+    return ctx.error('auth_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  return spec
+}
+
+module.exports = {
+  prepareAuth
+}
+`
+  }
+
+  const preamble = `
+const CRED_name = '${jsstr(spec.name)}'
+
+const OPTION_apikey = 'apikey'${spec.basic && 'header' === spec.where ? `
+const OPTION_secret = 'secret'` : ''}
+
+const NOTFOUND = '__NOTFOUND__'
+
+function prepareAuth(ctx) {
+  const utility = ctx.utility
+
+  const struct = utility.struct
+  const getprop = struct.getprop
+  const setprop = struct.setprop
+  const delprop = struct.delprop
+
+  const client = ctx.client
+  const spec = ctx.spec
+
+  if (null == spec) {
+    return ctx.error('auth_no_spec', 'Expected context spec property to be defined.')
+  }
+
+  const ${bag(spec.where)} = spec.${bag(spec.where)}
+
+  const options = client.options()
+
+  // Public APIs that need no auth omit the options.auth block entirely.
+  if (null == options.auth) {
+    ${clear(spec.where)}
+    return spec
+  }
+
+  const apikey = getprop(options, OPTION_apikey, NOTFOUND)
+`
+
+  // HTTP Basic is header-only by definition: the scheme is
+  // `Authorization: Basic base64(user:pass)`. It cannot be expressed as a
+  // query parameter or a cookie, so the branch is emitted only where it
+  // can mean something.
+  const basicBlock = (spec.basic && 'header' === spec.where) ? `
+  // True HTTP Basic Auth needs TWO credentials, base64-joined - a single
+  // token in the header (the branch below) can never authenticate against
+  // an API that actually checks \`Authorization: Basic base64(user:pass)\`.
+  if (true === options.auth.basic) {
+    const secret = getprop(options, OPTION_secret, NOTFOUND)
+    const noApikey = NOTFOUND === apikey || null == apikey || '' === apikey
+    const noSecret = NOTFOUND === secret || null == secret || '' === secret
+
+    if (noApikey || noSecret) {
+      delprop(headers, CRED_name)
+    }
+    else {
+      const b64 = Buffer.from(apikey + ':' + secret).toString('base64')
+      setprop(headers, CRED_name,
+        options.auth.prefix ? options.auth.prefix + ' ' + b64 : b64)
+    }
+
+    return spec
+  }
+` : ''
+
+  return preamble + basicBlock + `
+  if (NOTFOUND === apikey || null == apikey || '' === apikey) {
+    ${clear(spec.where)}
+  }
+  else {
+${place(spec.where)}
+  }
+
+  return spec
+}
+
+module.exports = {
+  prepareAuth
+}
+`
+}
+
+
+// The bag the credential lands in, per placement. Cookies ride the header
+// bag because a cookie IS a header.
+function bag(where: string): string {
+  return 'query' === where ? 'query' : 'headers'
+}
+
+
+function clear(where: string): string {
+  return 'query' === where ? 'delprop(query, CRED_name)' : 'delprop(headers, CRED_name)'
+}
+
+
+function place(where: string): string {
+  if ('query' === where) {
+    // NO PREFIX IN A QUERY STRING. `?token=Bearer%20abc` is not a thing any
+    // API reads; the prefix is a header convention and is dropped here
+    // deliberately rather than silently concatenated.
+    return `    setprop(query, CRED_name, apikey)`
+  }
+
+  if ('cookie' === where) {
+    // APPEND, never clobber: the request may already carry a session
+    // cookie set from options.headers, and a cookie header holds a
+    // '; '-joined list of pairs.
+    return `    const existing = getprop(headers, 'cookie', '')
+    const pair = CRED_name + '=' + apikey
+    setprop(headers, 'cookie', existing ? existing + '; ' + pair : pair)`
+  }
+
+  return `    // Empty prefix (raw apiKey credential) must not add a leading space.
+    setprop(headers, CRED_name,
+      options.auth.prefix ? options.auth.prefix + ' ' + apikey : apikey)`
+}
+
+
+function jsstr(s: string): string {
+  return String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+}
+
+
+export {
+  PrepareAuth
+}
+
+
+// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING. That helper is
+// also false whenever the SPEC declares no security scheme
+// (`main.kit.info.auth: false`) — a statement about the DEFINITION, not a
+// ban on ever sending a credential. `optspec` still declares `apikey` and
+// makeOptions fills `options.auth` from its defaults, so the runtime
+// `options.auth == null` guard never fired and those SDKs have always sent
+// the credential. Gating the body on `isAuthActive` does not trim dead
+// code, it removes working authentication — which
+// `js: auth null suppresses the credential` catches, and which takes the
+// secrets feature down with it.
+//
+// `main.kit.config.auth.active: false` is the project saying "no credential,
+// ever", and it is the only signal that can be honoured before runtime.
+function isAuthActive_js(model: any): boolean {
+  const auth = getModelPath(model, `main.${KIT}.config.auth`,
+    { only_active: false, required: false })
+  return !(null != auth && false === auth.active)
+}

package/project/.sdk/src/cmp/kotlin/Config_kotlin.ts

@@ -6,6 +6,9 @@ import {
   configDefinition,
   each,
   isAuthActive,
+  isHttpBasicAuth,
+  resolveAuthIn,
+  resolveAuthName,
   resolveAuthPrefix,
   targetFeatures,
 } from '@voxgig/sdkgen'
@@ -46,6 +49,17 @@ const Config = cmp(async function Config(props: any) {
 
   const authActive = isAuthActive(model)
   const authPrefix = resolveAuthPrefix(model)
+  const authBasic = isHttpBasicAuth(model)
+  // `in` and `name` travel with the prefix now. apidef resolved both all
+  // along, into main.kit.info.security, and this emitter dropped them - so
+  // an apiKey-in-query API got an Authorization header it does not read.
+  // The generated utility/PrepareAuth.kt is built from the same two values.
+  //
+  // Emitted only when they DIFFER from the defaults, so a
+  // header/Authorization SDK's Config.kt is byte-identical to what it
+  // generated before.
+  const authIn = resolveAuthIn(model)
+  const authName = resolveAuthName(model)
 
   let baseUrl = ''
   try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
@@ -74,7 +88,15 @@ const Config = cmp(async function Config(props: any) {
     base: baseUrl,
   }
   if (authActive) {
-    options.auth = { prefix: authPrefix }
+    const auth: Record<string, any> = { prefix: authPrefix }
+    // `basic` joins them for the same reason: the generated prepareAuth
+    // emits the base64(user:pass) branch only for a spec-declared HTTP
+    // Basic scheme, and that branch reads this option at runtime - without
+    // it the branch could never fire.
+    if (authBasic) { auth.basic = true }
+    if ('header' !== authIn) { auth.in = authIn }
+    if ('Authorization' !== authName) { auth.name = authName }
+    options.auth = auth
   }
   options.headers = headers
   options.entity = optionsEntity

package/project/.sdk/src/cmp/kotlin/Main_kotlin.ts

@@ -27,6 +27,7 @@ import { MainEntity } from './MainEntity_kotlin'
 import { EntityBase } from './EntityBase_kotlin'
 import { EntityTypes } from './EntityTypes_kotlin'
 import { SdkError } from './SdkError_kotlin'
+import { PrepareAuth } from './PrepareAuth_kotlin'
 import { kotlinPackage } from './utility_kotlin'
 
 
@@ -88,6 +89,25 @@ const Main = cmp(async function Main(props: any) {
   // Shared entity runtime (entity/EntityBase.kt).
   EntityBase({ target })
 
+  // utility/PrepareAuth.kt. GENERATED, NOT COPIED: where the credential
+  // goes - header, query parameter or cookie, under the name the spec gives
+  // - is a fact about the API, and tm/ can only hold one answer. It was
+  // embedded in tm/kotlin/utility/Prepare.kt among the other prepare*
+  // helpers, hardcoding an `authorization` header; that one function has
+  // moved out into its own compilation unit in the same package, so
+  // Register.kt's `u.prepareAuth = ::prepareAuth` binds it unchanged.
+  //
+  // Called HERE, at Main's TOP LEVEL, and deliberately NOT inside the
+  // `core` Folder below. The kotlin tree is FLAT: build.gradle.kts declares
+  // core/, utility/, feature/ and entity/ as four sibling source roots, and
+  // the Copy above lands tm/kotlin/utility/* at <out>/utility/. The
+  // component opens `utility` itself, exactly as EntityBase opens `entity`.
+  // Nested in `core` it would write core/utility/PrepareAuth.kt - which
+  // still COMPILES, because core/ is scanned recursively and the package
+  // declaration is what resolves the symbol, so the misfiling would be
+  // invisible to every check. See PrepareAuth_kotlin.
+  PrepareAuth({ target })
+
   // Generate the client class and config in core/.
   Folder({ name: 'core' }, () => {