@voxgig/sdkgen 4.19.1 → 4.20.0

package/src/utility.ts

@@ -75,6 +75,78 @@ function resolveAuthPrefix(model: any): string {
 }
 
 
+// AUTH SUPPRESSED AT GENERATION TIME — and ONLY by an explicit opt-out.
+//
+// NOT `isAuthActive`, and the difference is load-bearing. That helper is
+// also false when `main.kit.info.auth` is false, which only means the SPEC
+// declared no security scheme. Such an SDK still carries a credential:
+// `optspec` always declares `apikey`, and makeOptions fills `options.auth`
+// from the optspec defaults, so the runtime `null == options.auth` guard
+// never fires and the credential has always been sent. Emitting a no-op
+// prepareAuth for those SDKs silently breaks a working credential — and
+// takes the secrets feature with it, since that resolves a secret into
+// `options.apikey` and prepareAuth then places nothing.
+//
+// `main.kit.config.auth.active: false` is the project saying "this SDK
+// sends no credential, ever". That is the only signal that can be honoured
+// before runtime, so it is the only one used here.
+function isAuthSuppressed(model: any): boolean {
+  const auth = getModelPath(model, `main.${KIT}.config.auth`,
+    { only_active: false, required: false })
+  return null != auth && false === auth.active
+}
+
+
+// WHERE the credential goes, and UNDER WHAT NAME. Same priority order as
+// resolveAuthPrefix: a per-SDK override first, then what apidef derived
+// from the spec's securityScheme, then the convention.
+//
+// THESE EXISTED IN THE MODEL AND WERE DROPPED AT GENERATION. apidef has
+// always resolved `in` and `name` (transform/top.ts resolveSecurity), and
+// api-info.aon records them — joplin's says `in: "query", name: "token"`.
+// But nothing read them: every target's prepare_auth template hardcoded an
+// `authorization` header, so an apiKey-in-query API got a header it does
+// not read and never got the query parameter it does. Four repos in the
+// cedar fleet ship SDKs that cannot authenticate for this reason
+// (joplin `token`, pipedrive `api_token`, trello `key`,
+// lm-umbrella `apiKey`).
+//
+// 'header' and 'Authorization' remain the defaults, so every SDK whose
+// scheme is header-based generates exactly what it generated before.
+function resolveAuthIn(model: any): string {
+  const auth = getModelPath(model, `main.${KIT}.config.auth`,
+    { only_active: false, required: false })
+  if (null != auth && null != auth.in && '' !== auth.in) {
+    return String(auth.in).toLowerCase()
+  }
+
+  const security = getModelPath(model, `main.${KIT}.info.security`,
+    { only_active: false, required: false })
+  if (null != security && null != security.in && '' !== security.in) {
+    return String(security.in).toLowerCase()
+  }
+
+  return 'header'
+}
+
+
+function resolveAuthName(model: any): string {
+  const auth = getModelPath(model, `main.${KIT}.config.auth`,
+    { only_active: false, required: false })
+  if (null != auth && null != auth.name && '' !== auth.name) {
+    return String(auth.name)
+  }
+
+  const security = getModelPath(model, `main.${KIT}.info.security`,
+    { only_active: false, required: false })
+  if (null != security && null != security.name && '' !== security.name) {
+    return String(security.name)
+  }
+
+  return 'Authorization'
+}
+
+
 // True when the spec's security scheme is genuine HTTP Basic Auth (two
 // credentials, base64-joined) rather than a single bearer-style token with
 // a prefix. Priority order mirrors resolveAuthPrefix:
@@ -157,6 +229,9 @@ export {
   requirePath,
   isAuthActive,
   resolveAuthPrefix,
+  resolveAuthIn,
+  resolveAuthName,
+  isAuthSuppressed,
   resolveAuthExchange,
   isHttpBasicAuth,
   SdkGenError,

package/project/.sdk/tm/c/utility/prepare_auth.c

@@ -1,65 +0,0 @@
-// prepare_auth utility (mirrors utility/prepare_auth.rs).
-
-#include "sdk.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#define HEADER_AUTH "authorization"
-#define OPTION_APIKEY "apikey"
-#define NOT_FOUND "__NOTFOUND__"
-
-Spec* prepare_auth_util(Context* ctx, PNError** err) {
-  *err = NULL;
-  Spec* spec = ctx->spec;
-  if (!spec) {
-    *err = context_make_error(ctx, "auth_no_spec", "Expected context spec property to be defined.");
-    return NULL;
-  }
-
-  voxgig_value* headers = spec->headers;
-  voxgig_value* options = ctx->client ? sdk_options_map(ctx->client) : ctx->options;
-
-  voxgig_value* auth = getp(options, "auth");
-  if (v_is_noval(auth) || v_is_null(auth)) {
-    voxgig_value* k = voxgig_new_string(HEADER_AUTH);
-    voxgig_delprop(headers, k);
-    voxgig_release(k);
-    return spec;
-  }
-
-  voxgig_value* akey_key = voxgig_new_string(OPTION_APIKEY);
-  voxgig_value* nf = voxgig_new_string(NOT_FOUND);
-  voxgig_value* apikey = voxgig_getprop(options, akey_key, nf);
-  voxgig_release(akey_key);
-  voxgig_release(nf);
-
-  bool skip;
-  if (v_is_noval(apikey) || v_is_null(apikey)) {
-    skip = true;
-  } else if (voxgig_is_string(apikey)) {
-    const char* s = voxgig_as_string(apikey);
-    skip = (strcmp(s, NOT_FOUND) == 0 || s[0] == '\0');
-  } else {
-    skip = false;
-  }
-
-  if (skip) {
-    voxgig_value* k = voxgig_new_string(HEADER_AUTH);
-    voxgig_delprop(headers, k);
-    voxgig_release(k);
-  } else {
-    voxgig_value* prefix_v = getpath2(options, "auth", "prefix");
-    const char* auth_prefix = voxgig_is_string(prefix_v) ? voxgig_as_string(prefix_v) : "";
-    const char* apikey_val = voxgig_is_string(apikey) ? voxgig_as_string(apikey) : "";
-    if (auth_prefix[0] == '\0') {
-      setp(headers, HEADER_AUTH, v_str(apikey_val));
-    } else {
-      char buf[1024];
-      snprintf(buf, sizeof(buf), "%s %s", auth_prefix, apikey_val);
-      setp(headers, HEADER_AUTH, v_str(buf));
-    }
-  }
-
-  return spec;
-}

package/project/.sdk/tm/csharp/utility/PrepareAuth.cs

@@ -1,54 +0,0 @@
-// ProjectName SDK utility: prepareAuth - shape the authorization header
-// from the client options.
-
-using Voxgig.Struct;
-
-namespace ProjectNameSdk.Util;
-
-public static partial class SdkUtility
-{
-    private const string HeaderAuth = "authorization";
-    private const string OptionApikey = "apikey";
-    private const string NotFound = "__NOTFOUND__";
-
-    internal static Spec PrepareAuthUtil(Context ctx)
-    {
-        var spec = ctx.Spec ?? throw ctx.MakeError("auth_no_spec",
-            "Expected context spec property to be defined.");
-
-        var headers = spec.Headers;
-        var options = ctx.Client!.OptionsMap();
-
-        // Public APIs that need no auth omit the options.auth block entirely.
-        if (!options.TryGetValue("auth", out var auth) || auth == null)
-        {
-            headers.Remove(HeaderAuth);
-            return spec;
-        }
-
-        var apikey = StructUtils.GetProp(options, OptionApikey, NotFound);
-
-        var skip = apikey == null ||
-            (apikey is string apikeyStr && (apikeyStr == NotFound || apikeyStr == ""));
-
-        if (skip)
-        {
-            headers.Remove(HeaderAuth);
-        }
-        else
-        {
-            var authPrefix = "";
-            if (StructUtils.GetPath(options, StructUtils.Jt("auth", "prefix")) is string ap)
-            {
-                authPrefix = ap;
-            }
-            var apikeyVal = apikey as string ?? "";
-            // Empty prefix (raw apiKey credential) must not add a leading space.
-            headers[HeaderAuth] = authPrefix == ""
-                ? apikeyVal
-                : authPrefix + " " + apikeyVal;
-        }
-
-        return spec;
-    }
-}

package/project/.sdk/tm/go/utility/prepare_auth.go

@@ -1,59 +0,0 @@
-package utility
-
-import (
-	vs "github.com/voxgig/struct"
-
-	"GOMODULE/core"
-)
-
-const headerAuth = "authorization"
-const optionApikey = "apikey"
-const notFound = "__NOTFOUND__"
-
-func prepareAuthUtil(ctx *core.Context) (*core.Spec, error) {
-	spec := ctx.Spec
-	if spec == nil {
-		return nil, ctx.MakeError("auth_no_spec",
-			"Expected context spec property to be defined.")
-	}
-
-	headers := spec.Headers
-	options := ctx.Client.OptionsMap()
-
-	// Public APIs that need no auth omit the options.auth block entirely.
-	if options["auth"] == nil {
-		delete(headers, headerAuth)
-		return spec, nil
-	}
-
-	apikey := vs.GetProp(options, optionApikey, notFound)
-
-	skip := false
-	if apikey == nil {
-		skip = true
-	} else if apikeyStr, ok := apikey.(string); ok &&
-		(apikeyStr == notFound || apikeyStr == "") {
-		skip = true
-	}
-
-	if skip {
-		delete(headers, headerAuth)
-	} else {
-		authPrefix := ""
-		if ap := vs.GetPath(options, []any{"auth", "prefix"}); ap != nil {
-			authPrefix, _ = ap.(string)
-		}
-		apikeyVal := ""
-		if av, ok := apikey.(string); ok {
-			apikeyVal = av
-		}
-		// Empty prefix (raw apiKey credential) must not add a leading space.
-		if authPrefix == "" {
-			headers[headerAuth] = apikeyVal
-		} else {
-			headers[headerAuth] = authPrefix + " " + apikeyVal
-		}
-	}
-
-	return spec, nil
-}

package/project/.sdk/tm/java/utility/PrepareAuth.java

@@ -1,66 +0,0 @@
-package JAVAPACKAGE.utility;
-
-import java.util.List;
-import java.util.Map;
-
-import JAVAPACKAGE.core.Context;
-import JAVAPACKAGE.core.Spec;
-import JAVAPACKAGE.utility.struct.Struct;
-
-final class PrepareAuth {
-
-  private PrepareAuth() {}
-
-  static final String HEADER_AUTH = "authorization";
-  static final String OPTION_APIKEY = "apikey";
-  static final String NOT_FOUND = "__NOTFOUND__";
-
-  static Spec prepareAuth(Context ctx) {
-    Spec spec = ctx.spec;
-    if (spec == null) {
-      throw ctx.makeError("auth_no_spec",
-          "Expected context spec property to be defined.");
-    }
-
-    Map<String, Object> headers = spec.headers;
-    Map<String, Object> options = ctx.client.optionsMap();
-
-    // Public APIs that need no auth omit the options.auth block entirely.
-    if (options.get("auth") == null) {
-      headers.remove(HEADER_AUTH);
-      return spec;
-    }
-
-    Object apikey = Struct.getprop(options, OPTION_APIKEY, NOT_FOUND);
-
-    boolean skip = false;
-    if (apikey == null) {
-      skip = true;
-    }
-    else if (apikey instanceof String
-        && (NOT_FOUND.equals(apikey) || "".equals(apikey))) {
-      skip = true;
-    }
-
-    if (skip) {
-      headers.remove(HEADER_AUTH);
-    }
-    else {
-      String authPrefix = "";
-      Object ap = Struct.getpath(options, List.of("auth", "prefix"));
-      if (ap instanceof String) {
-        authPrefix = (String) ap;
-      }
-      String apikeyVal = apikey instanceof String ? (String) apikey : "";
-      // Empty prefix (raw apiKey credential) must not add a leading space.
-      if ("".equals(authPrefix)) {
-        headers.put(HEADER_AUTH, apikeyVal);
-      }
-      else {
-        headers.put(HEADER_AUTH, authPrefix + " " + apikeyVal);
-      }
-    }
-
-    return spec;
-  }
-}

package/project/.sdk/tm/js/src/utility/PrepareAuthUtility.js

@@ -1,49 +0,0 @@
-
-const HEADER_auth = 'authorization'
-
-const OPTION_apikey = 'apikey'
-
-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 headers = spec.headers
-
-  const options = client.options()
-
-  // Public APIs that need no auth omit the options.auth block entirely.
-  if (null == options.auth) {
-    delprop(headers, HEADER_auth)
-    return spec
-  }
-
-  const apikey = getprop(options, OPTION_apikey, NOTFOUND)
-
-  if (NOTFOUND === apikey || null == apikey || '' === apikey) {
-    delprop(headers, HEADER_auth)
-  }
-  else {
-    // Empty prefix (raw apiKey credential) must not add a leading space.
-    setprop(headers, HEADER_auth,
-      options.auth.prefix ? options.auth.prefix + ' ' + apikey : apikey)
-  }
-
-  return spec
-}
-
-module.exports = {
-  prepareAuth
-}

package/project/.sdk/tm/lua/utility/prepare_auth.lua

@@ -1,52 +0,0 @@
--- ProjectName SDK utility: prepare_auth
-
-local vs = require("utility.struct.struct")
-
-local HEADER_AUTH = "authorization"
-local OPTION_APIKEY = "apikey"
-local NOT_FOUND = "__NOTFOUND__"
-
-local function prepare_auth_util(ctx)
-  local spec = ctx.spec
-  if spec == nil then
-    return nil, ctx:make_error("auth_no_spec",
-      "Expected context spec property to be defined.")
-  end
-
-  local headers = spec.headers
-  local options = ctx.client:options_map()
-
-  -- Public APIs that need no auth omit the options.auth block entirely.
-  if options.auth == nil then
-    headers[HEADER_AUTH] = nil
-    return spec, nil
-  end
-
-  local apikey = vs.getprop(options, OPTION_APIKEY, NOT_FOUND)
-
-  if apikey == nil
-    or (type(apikey) == "string" and (apikey == NOT_FOUND or apikey == ""))
-  then
-    headers[HEADER_AUTH] = nil
-  else
-    local auth_prefix = ""
-    local ap = vs.getpath(options, "auth.prefix")
-    if type(ap) == "string" then
-      auth_prefix = ap
-    end
-    local apikey_val = ""
-    if type(apikey) == "string" then
-      apikey_val = apikey
-    end
-    -- Empty prefix (raw apiKey credential) must not add a leading space.
-    if auth_prefix == "" then
-      headers[HEADER_AUTH] = apikey_val
-    else
-      headers[HEADER_AUTH] = auth_prefix .. " " .. apikey_val
-    end
-  end
-
-  return spec, nil
-end
-
-return prepare_auth_util

package/project/.sdk/tm/perl/utility/prepare_auth.pm

@@ -1,56 +0,0 @@
-# ProjectName SDK utility: prepare_auth
-
-use strict;
-use warnings;
-
-use File::Basename ();
-use Cwd ();
-
-my $__dir;
-BEGIN { $__dir = File::Basename::dirname(Cwd::abs_path(__FILE__)) }
-require(Cwd::abs_path("$__dir/../lib/Voxgig/Struct.pm"));
-require(Cwd::abs_path("$__dir/../core/helpers.pm"));
-
-package ProjectNameUtilities;
-
-our %REGISTRY;
-
-my $HEADER_AUTH = 'authorization';
-my $OPTION_APIKEY = 'apikey';
-my $NOT_FOUND = '__NOTFOUND__';
-
-$REGISTRY{prepare_auth} = sub {
-  my ($ctx) = @_;
-  my $spec = $ctx->{spec};
-  return (undef, $ctx->make_error('auth_no_spec',
-    'Expected context spec property to be defined.')) unless $spec;
-
-  my $headers = $spec->{headers};
-  my $options = $ctx->{client}->options_map;
-
-  # Public APIs that need no auth omit the options.auth block entirely.
-  if (!defined ProjectNameHelpers::gp($options, 'auth')) {
-    delete $headers->{$HEADER_AUTH};
-    return ($spec, undef);
-  }
-
-  my $apikey = Voxgig::Struct::getprop($options, $OPTION_APIKEY, $NOT_FOUND);
-
-  if (!defined $apikey || Voxgig::Struct::is_none($apikey)
-    || Voxgig::Struct::is_jnull($apikey)
-    || (!ref $apikey && ($apikey eq $NOT_FOUND || $apikey eq ''))) {
-    delete $headers->{$HEADER_AUTH};
-  }
-  else {
-    my $auth_prefix = ProjectNameHelpers::gpath($options, 'auth.prefix');
-    $auth_prefix = '' unless defined $auth_prefix && !ref $auth_prefix;
-    my $apikey_val = (!ref $apikey) ? "$apikey" : '';
-    # Empty prefix (raw apiKey credential) must not add a leading space.
-    $headers->{$HEADER_AUTH} =
-      ('' eq $auth_prefix) ? $apikey_val : "$auth_prefix $apikey_val";
-  }
-
-  return ($spec, undef);
-};
-
-1;

package/project/.sdk/tm/php/utility/PrepareAuth.php

@@ -1,45 +0,0 @@
-<?php
-declare(strict_types=1);
-
-// ProjectName SDK utility: prepare_auth
-
-class ProjectNamePrepareAuth
-{
-    private const HEADER_AUTH = 'authorization';
-    private const OPTION_APIKEY = 'apikey';
-    private const NOT_FOUND = '__NOTFOUND__';
-
-    public static function call(ProjectNameContext $ctx): array
-    {
-        $spec = $ctx->spec;
-        if (!$spec) {
-            return [null, $ctx->make_error('auth_no_spec', 'Expected context spec property to be defined.')];
-        }
-
-        $headers = &$spec->headers;
-        $options = $ctx->client->options_map();
-
-        // Public APIs that need no auth omit the options.auth block entirely.
-        if (!isset($options['auth']) || $options['auth'] === null) {
-            unset($headers[self::HEADER_AUTH]);
-            return [$spec, null];
-        }
-
-        $apikey = \Voxgig\Struct\Struct::getprop($options, self::OPTION_APIKEY, self::NOT_FOUND);
-
-        if (
-            (is_string($apikey) && ($apikey === self::NOT_FOUND || $apikey === ''))
-            || $apikey === null
-        ) {
-            unset($headers[self::HEADER_AUTH]);
-        } else {
-            $auth_prefix = \Voxgig\Struct\Struct::getpath($options, 'auth.prefix') ?? '';
-            $apikey_val = is_string($apikey) ? $apikey : '';
-            // Empty prefix (raw apiKey credential) must not add a leading space.
-            $headers[self::HEADER_AUTH] = $auth_prefix === ''
-                ? $apikey_val : "{$auth_prefix} {$apikey_val}";
-        }
-
-        return [$spec, null];
-    }
-}

package/project/.sdk/tm/py/pkg/utility/prepare_auth.py

@@ -1,46 +0,0 @@
-# ProjectName SDK utility: prepare_auth
-
-from __future__ import annotations
-from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
-
-HEADER_AUTH = "authorization"
-OPTION_APIKEY = "apikey"
-NOT_FOUND = "__NOTFOUND__"
-
-
-def prepare_auth_util(ctx):
-    spec = ctx.spec
-    if spec is None:
-        return None, ctx.make_error("auth_no_spec",
-            "Expected context spec property to be defined.")
-
-    headers = spec.headers
-    options = ctx.client.options_map()
-
-    # Public APIs that need no auth omit the options.auth block entirely.
-    if options.get("auth") is None:
-        headers.pop(HEADER_AUTH, None)
-        return spec, None
-
-    apikey = vs.getprop(options, OPTION_APIKEY, NOT_FOUND)
-
-    if (
-        (isinstance(apikey, str) and apikey == NOT_FOUND)
-        or apikey is None
-        or apikey == ""
-    ):
-        headers.pop(HEADER_AUTH, None)
-    else:
-        auth_prefix = ""
-        ap = vs.getpath(options, "auth.prefix")
-        if isinstance(ap, str):
-            auth_prefix = ap
-        apikey_val = ""
-        if isinstance(apikey, str):
-            apikey_val = apikey
-        # Empty prefix (raw apiKey credential) must not add a leading space.
-        headers[HEADER_AUTH] = (
-            auth_prefix + " " + apikey_val if auth_prefix else apikey_val
-        )
-
-    return spec, None

package/project/.sdk/tm/rb/utility/prepare_auth.rb

@@ -1,35 +0,0 @@
-# ProjectName SDK utility: prepare_auth
-require_relative 'struct/voxgig_struct'
-module ProjectNameUtilities
-  HEADER_AUTH = "authorization"
-  OPTION_APIKEY = "apikey"
-  NOT_FOUND = "__NOTFOUND__"
-
-  PrepareAuth = ->(ctx) {
-    spec = ctx.spec
-    return nil, ctx.make_error("auth_no_spec", "Expected context spec property to be defined.") unless spec
-
-    headers = spec.headers
-    options = ctx.client.options_map
-
-    # Public APIs that need no auth omit the options.auth block entirely.
-    if options["auth"].nil?
-      headers.delete(HEADER_AUTH)
-      return spec, nil
-    end
-
-    apikey = VoxgigStruct.getprop(options, OPTION_APIKEY, NOT_FOUND)
-
-    if apikey.nil? || (apikey.is_a?(String) && (apikey == NOT_FOUND || apikey == ""))
-      headers.delete(HEADER_AUTH)
-    else
-      auth_prefix = VoxgigStruct.getpath(options, "auth.prefix") || ""
-      apikey_val = apikey.is_a?(String) ? apikey : ""
-      # Empty prefix (raw apiKey credential) must not add a leading space.
-      headers[HEADER_AUTH] =
-        auth_prefix.empty? ? apikey_val : "#{auth_prefix} #{apikey_val}"
-    end
-
-    return spec, nil
-  }
-end

package/project/.sdk/tm/rust/utility/prepare_auth.rs

@@ -1,65 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-
-use crate::core::context::Context;
-use crate::core::error::ProjectNameError;
-use crate::core::helpers::{getp, getpath, setp};
-use crate::core::spec::Spec;
-use crate::utility::voxgigstruct as vs;
-use crate::utility::voxgigstruct::Value;
-
-const HEADER_AUTH: &str = "authorization";
-const OPTION_APIKEY: &str = "apikey";
-const NOT_FOUND: &str = "__NOTFOUND__";
-
-pub fn prepare_auth_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNameError> {
-    let spec = ctx.spec.borrow().clone().ok_or_else(|| {
-        ctx.make_error("auth_no_spec", "Expected context spec property to be defined.")
-    })?;
-
-    let headers = spec.borrow().headers.clone();
-    let options = match ctx.client.borrow().clone() {
-        Some(client) => client.options_map(),
-        None => ctx.options.borrow().clone(),
-    };
-
-    // Public APIs that need no auth omit the options.auth block entirely.
-    let auth = getp(&options, "auth");
-    if auth.is_noval() || auth.is_null() {
-        vs::del_prop(headers, &Value::str(HEADER_AUTH));
-        return Ok(spec);
-    }
-
-    let apikey = vs::get_prop(&options, &Value::str(OPTION_APIKEY), Value::str(NOT_FOUND));
-
-    let skip = match &apikey {
-        Value::Noval | Value::Null => true,
-        Value::Str(s) => s == NOT_FOUND || s.is_empty(),
-        _ => false,
-    };
-
-    if skip {
-        vs::del_prop(headers, &Value::str(HEADER_AUTH));
-    } else {
-        let auth_prefix = match getpath(&["auth", "prefix"], &options) {
-            Value::Str(s) => s,
-            _ => String::new(),
-        };
-        let apikey_val = match &apikey {
-            Value::Str(s) => s.clone(),
-            _ => String::new(),
-        };
-        // Empty prefix (raw apiKey credential) must not add a leading space.
-        if auth_prefix.is_empty() {
-            setp(&headers, HEADER_AUTH, Value::str(apikey_val));
-        } else {
-            setp(
-                &headers,
-                HEADER_AUTH,
-                Value::str(format!("{} {}", auth_prefix, apikey_val)),
-            );
-        }
-    }
-
-    Ok(spec)
-}