@voxgig/sdkgen 3.4.3 → 3.4.6

package/project/.sdk/src/cmp/lua/Config_lua.ts

@@ -8,8 +8,11 @@ import {
   Fragment,
   Line,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
   resolveAuthPrefix,
   serverVariables,
 } from '@voxgig/sdkgen'
@@ -26,6 +29,7 @@ import {
 import {
   clean,
   formatLuaTable,
+  luaLongString,
 } from './utility_lua'
 
 
@@ -61,11 +65,54 @@ const Config = cmp(async function Config(props: any) {
       },\n`
     : ''
 
+  // The same config as an OBJECT, built by the shared helper so this target's
+  // literal and the data that replaces it above the threshold are the same
+  // config by construction. The JSON is what the threshold is measured on -
+  // emitted source size varies by language, the model does not.
+  const { json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`-- ${model.const.Name} SDK configuration
 
--- Build a fresh, fully materialised config table. Every call rebuilds the
+`)
+
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // A table constructor makes the Lua parser emit a SETTABLE per entry and
+    // the VM run them all on every load; a long-bracket string is one token,
+    // and dkjson's decoder builds the table from it.
+    //
+    // dkjson is already a runtime dependency - `utility/fetcher.lua` decodes
+    // every HTTP response with it - so this adds nothing to the SDK.
+    //
+    // Null handling agrees between the branches by construction: dkjson maps
+    // JSON null to nil, and assigning nil to a table key removes it, which is
+    // exactly what the literal branch does when `formatLuaTable` emits `nil`.
+    if (asData) {
+      Content(`local json = require("dkjson")
+
+
+-- THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+--
+-- Emitted only above a size threshold, or when \`main.kit.config.repr\` pins
+-- it: for a small model the table literal is smaller and far easier to read
+-- when debugging.
+local CONFIG_DATA = ${luaLongString(configJson)}
+
+
+-- Parse a fresh, fully materialised config table. Every call re-parses, so
+-- prefer require("config_shared") unless you need a private copy you intend
+-- to mutate.
+local function make_config()
+  return json.decode(CONFIG_DATA)
+end
+`)
+    }
+    else {
+
+    Content(`-- Build a fresh, fully materialised config table. Every call rebuilds the
 -- whole structure, so prefer require("config_shared") unless you need a
 -- private copy you intend to mutate.
 local function make_config()
@@ -105,7 +152,10 @@ ${serverBlock}${authBlock}      headers = ${formatLuaTable(headers, 3)},
       }, true), a), {}), 2)},
   }
 end
+`)
+    }
 
+    Content(`
 
 local function make_feature(name)
   local features = require("features")

package/project/.sdk/src/cmp/lua/utility_lua.ts

@@ -127,7 +127,28 @@ function clean(o: any, dropDefaults?: boolean): any {
 }
 
 
+
+// A Lua LONG-BRACKET string holding `s` verbatim.
+//
+// Lua's quoted strings process escapes, so the JSON's own `\n` and `\uXXXX`
+// would be consumed by the Lua lexer before the JSON decoder ever saw them -
+// turning an escaped newline into a real one inside a JSON string (invalid
+// JSON), and failing outright on `\uXXXX`, which Lua 5.1/5.2 do not accept at
+// all. A long bracket processes nothing, so the JSON text survives byte for
+// byte. The level is raised until its terminator does not occur in the text.
+function luaLongString(s: string): string {
+  let level = 0
+  while (s.includes(']' + '='.repeat(level) + ']')) {
+    level++
+  }
+  const eq = '='.repeat(level)
+  // A long bracket swallows an immediately following newline, so start the
+  // content on the same line as the opener.
+  return '[' + eq + '[' + s + ']' + eq + ']'
+}
+
 export {
+  luaLongString,
   clean,
   formatLuaTable,
   formatLuaValue,

package/project/.sdk/src/cmp/php/Config_php.ts

@@ -8,8 +8,12 @@ import {
   Fragment,
   Line,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
+  rawStringLiteral,
   resolveAuthPrefix,
   serverVariables,
 } from '@voxgig/sdkgen'
@@ -63,6 +67,13 @@ const Config = cmp(async function Config(props: any) {
                 ],\n`
     : ''
 
+  // The same config as an OBJECT, built by the shared helper so this target's
+  // literal and the data that replaces it above the threshold are the same
+  // config by construction. The JSON is what the threshold is measured on -
+  // emitted source size varies by language, the model does not.
+  const { json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`<?php
@@ -91,7 +102,79 @@ class ${model.const.Name}Config
         return self::$shared_config;
     }
 
+`)
+
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // An array literal is compiled opcode by opcode and held in the opcache
+    // entry for this file; a string constant is one token, and `json_decode`
+    // (C) builds the array far faster than the equivalent literal.
+    //
+    // PHP cannot tell an empty list from an empty map, so `{}` and `[]` decode
+    // to the same value and the two representations have to AGREE about which
+    // one the literal would have produced. `formatPhpArray` emits `[]` for
+    // every empty map, and the literal branch hand-writes `(object)[]` in
+    // exactly two places - `entity` and `options.entity`, and only when the
+    // model declares no entities at all, because the SDK runtime validator
+    // wants a map there. This reproduces that rule rather than improving on
+    // it: an emission wart is not something the data path gets to fix
+    // unilaterally, or the two branches stop being interchangeable.
+    //
+    // A SINGLE-quoted literal, so the JSON survives verbatim: a double-quoted
+    // PHP string would interpolate any `$name` the model contains - and the
+    // model is full of them (`$STRING`, `$action`).
+    if (asData) {
+      Content(`    /**
+     * THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+     *
+     * Emitted only above a size threshold, or when \`main.kit.config.repr\`
+     * pins it: for a small model the array literal is smaller and far easier
+     * to read when debugging.
+     */
+    private const CONFIG_DATA = ${rawStringLiteral(configJson)};
+
+    /**
+     * Decoded JSON in the shape the literal branch produces: every map
+     * becomes an array, including an empty one.
+     */
+    private static function config_decode(mixed $v): mixed
+    {
+        if ($v instanceof \\stdClass) {
+            $out = [];
+            foreach (get_object_vars($v) as $k => $c) {
+                $out[$k] = self::config_decode($c);
+            }
+            return $out;
+        }
+        if (is_array($v)) {
+            return array_map([self::class, 'config_decode'], $v);
+        }
+        return $v;
+    }
+
     /**
+     * Parse a fresh, fully materialised config array. Every call re-parses,
+     * so prefer shared_config unless you need a private copy.
+     */
+    public static function make_config(): array
+    {
+        /** @var array<string,mixed> $out */
+        $out = self::config_decode(json_decode(self::CONFIG_DATA));
+
+        // The two map-shape exceptions the literal branch makes by hand.
+        if (count($out["entity"]) === 0) {
+            $out["entity"] = (object)[];
+        }
+        if (count($out["options"]["entity"]) === 0) {
+            $out["options"]["entity"] = (object)[];
+        }
+        return $out;
+    }
+`)
+    }
+    else {
+
+    Content(`    /**
      * Build a fresh, fully materialised config array. Every call rebuilds the
      * whole structure, so prefer shared_config unless you need a private copy.
      */
@@ -151,7 +234,10 @@ ${serverBlock}${authBlock}                "headers" => ${formatPhpArray(headers,
     }
 
     Content(`    }
+`)
+    }
 
+    Content(`
 
     public static function make_feature(string $name)
     {

package/project/.sdk/src/cmp/py/Config_py.ts

@@ -8,8 +8,11 @@ import {
   Fragment,
   Line,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
   resolveAuthPrefix,
   serverVariables,
 } from '@voxgig/sdkgen'
@@ -61,10 +64,17 @@ const Config = cmp(async function Config(props: any) {
             },\n`
     : ''
 
+  // The same config as an OBJECT, built by the shared helper so this target's
+  // literal and the data that replaces it above the threshold are the same
+  // config by construction. The JSON is what the threshold is measured on -
+  // emitted source size varies by language, the model does not.
+  const { json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`# ${model.const.Name} SDK configuration
-
+${asData ? '\nimport json\n' : ''}
 
 _shared_config = None
 
@@ -84,7 +94,43 @@ def shared_config():
     return _shared_config
 
 
+`)
+
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // A dict literal makes CPython build the whole structure opcode by opcode
+    // at import, and the compiler hold the entire literal in memory to produce
+    // that bytecode. A string constant is one object, and `json.loads` (the C
+    // scanner) builds the dict far faster than the equivalent literal.
+    //
+    // `json.loads` yields exactly what the literal did - str keys, int for
+    // whole numbers, True/False/None - so make_config's result is unchanged.
+    //
+    // JSON.stringify output is a valid Python string literal: every escape it
+    // emits (\\", \\\\, \\n, \\uXXXX) means the same thing in Python, it never emits
+    // \\/ (which Python would not treat as an escape), and Python 3 source is
+    // UTF-8 so non-ASCII needs no escaping.
+    if (asData) {
+      Content(`# THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+#
+# Emitted only above a size threshold, or when \`main.kit.config.repr\` pins it:
+# for a small model the dict literal is smaller and far easier to read when
+# debugging.
+_CONFIG_DATA = ${JSON.stringify(configJson)}
+
+
 def make_config():
+    """Parse a fresh, fully materialised config dict.
+
+    Every call re-parses, so prefer shared_config unless you need a private
+    copy you intend to mutate.
+    """
+    return json.loads(_CONFIG_DATA)
+`)
+      return
+    }
+
+    Content(`def make_config():
     """Build a fresh, fully materialised config dict.
 
     Every call rebuilds the whole structure, so prefer shared_config unless

package/project/.sdk/src/cmp/rb/Config_rb.ts

@@ -8,8 +8,12 @@ import {
   Fragment,
   Line,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
+  rawStringLiteral,
   resolveAuthPrefix,
   serverVariables,
 } from '@voxgig/sdkgen'
@@ -63,10 +67,17 @@ const Config = cmp(async function Config(props: any) {
         },\n`
     : ''
 
+  // The same config as an OBJECT, built by the shared helper so this target's
+  // literal and the data that replaces it above the threshold are the same
+  // config by construction. The JSON is what the threshold is measured on -
+  // emitted source size varies by language, the model does not.
+  const { json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`# ${model.const.Name} SDK configuration
-
+${asData ? "\nrequire 'json'\n" : ''}
 module ${model.const.Name}Config
   # Return the process-wide config, built once on first use. The SDK reads
   # the config on every request and never writes to it, so one instance is
@@ -79,7 +90,37 @@ module ${model.const.Name}Config
   end
 
 
-  # Build a fresh, fully materialised config hash. Every call rebuilds the
+`)
+
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // A hash literal makes the Ruby parser build a node per entry and the VM
+    // execute an instruction per entry on every load. A string constant is one
+    // token, and `JSON.parse` (a C extension) builds the hash far faster.
+    //
+    // `JSON.parse` yields exactly what the literal did - String keys, Integer
+    // for whole numbers, true/false/nil - so make_config's result is unchanged.
+    //
+    // A SINGLE-quoted literal, so the JSON survives verbatim: a double-quoted
+    // Ruby string would interpolate any `#{` the model happens to contain.
+    if (asData) {
+      Content(`  # THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+  #
+  # Emitted only above a size threshold, or when \`main.kit.config.repr\` pins
+  # it: for a small model the hash literal is smaller and far easier to read
+  # when debugging.
+  CONFIG_DATA = ${rawStringLiteral(configJson)}.freeze
+
+  # Parse a fresh, fully materialised config hash. Every call re-parses, so
+  # prefer shared_config unless you need a private copy you intend to mutate.
+  def self.make_config
+    JSON.parse(CONFIG_DATA)
+  end
+`)
+    }
+    else {
+
+    Content(`  # Build a fresh, fully materialised config hash. Every call rebuilds the
   # whole structure, so prefer shared_config unless you need a private copy
   # you intend to mutate.
   def self.make_config
@@ -119,7 +160,10 @@ ${serverBlock}${authBlock}        "headers" => ${formatRubyHash(headers, 4)},
       }, true), a), {}), 3)},
     }
   end
+`)
+    }
 
+    Content(`
 
   def self.make_feature(name)
     require_relative 'features'

package/project/.sdk/src/cmp/rust/Config_rust.ts

@@ -3,8 +3,11 @@ import {
   Content,
   File,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
   resolveAuthPrefix,
 } from '@voxgig/sdkgen'
 
@@ -17,8 +20,8 @@ import {
 
 
 import {
-  clean,
   formatRustValue,
+  rustRawString,
 } from './utility_rust'
 
 
@@ -43,43 +46,54 @@ const Config = cmp(async function Config(props: any) {
   let baseUrl = ''
   try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
 
-  // Assemble the whole config as a JSON-shaped object, then render it once
-  // via formatRustValue (byte-stable; each() sorted-key iteration).
-  const featureConfig: any = {}
-  each(feature, (f: any) => {
-    featureConfig[f.name] = f.config || {}
-  })
+  // The canonical config OBJECT and its JSON, from the shared helper. Both
+  // representations render from the same `def`, so they cannot describe
+  // different configs - and this target picks up `options.server` (the
+  // OpenAPI server-variable defaults), which the hand-rolled build here
+  // omitted entirely.
+  const { def: config, json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
 
-  const entityOptions: any = {}
-  each(entity, (ent: any) => {
-    entityOptions[ent.name] = {}
-  })
+  File({ name: 'config.' + target.ext }, () => {
 
-  const options: any = {
-    base: baseUrl,
-    headers,
-    entity: entityOptions,
-  }
-  if (authActive) {
-    options.auth = { prefix: authPrefix }
-  }
-
-  const entityConfig = Object.values(entity || {}).reduce((a: any, n: any) => (
-    a[n.name] = clean({
-      fields: n.fields,
-      name: n.name,
-      op: n.op,
-      relations: n.relations,
-    }, true), a), {})
-
-  const config = {
-    main: { name: model.const.Name },
-    feature: featureConfig,
-    options,
-    entity: entityConfig,
-  }
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // The literal is one deeply nested expression. rustc type-checks and
+    // monomorphises it as a single item, so compile time and memory grow with
+    // the whole model at once; a string constant is one token, and json_parse
+    // builds the same Value tree at runtime.
+    //
+    // No number-type question here, unlike Go: `Value::Num` is f64 in both
+    // representations, so there is nothing for the two paths to disagree about.
+    if (asData) {
+      Content(`// Generated API configuration (mirrors go core/config.go).
 
-  File({ name: 'config.' + target.ext }, () => {
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::types::FeatureRef;
+use crate::utility::jsonparse::json_parse;
+use crate::utility::voxgigstruct::Value;
+
+/// THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+///
+/// Emitted only above a size threshold, or when \`main.kit.config.repr\` pins
+/// it: for a small model the literal is smaller and far easier to read when
+/// debugging.
+const CONFIG_DATA: &str = ${rustRawString(configJson)};
+
+pub fn make_config() -> Value {
+    // Unreachable on error: the constant is generated by a JSON serialiser and
+    // never edited by hand. Panicking beats returning an empty config, which
+    // would fail far from the cause.
+    json_parse(CONFIG_DATA).expect("${model.const.Name}: embedded config is not valid JSON")
+}
+
+pub fn make_feature(name: &str) -> FeatureRef {
+    match name {
+`)
+    }
+    else {
 
     Content(`// Generated API configuration (mirrors go core/config.go).
 
@@ -96,6 +110,7 @@ pub fn make_config() -> Value {
 pub fn make_feature(name: &str) -> FeatureRef {
     match name {
 `)
+    }
 
     each(feature, (f: any) => {
       const fname = f.name.charAt(0).toUpperCase() + f.name.slice(1)

package/project/.sdk/src/cmp/rust/utility_rust.ts

@@ -146,7 +146,24 @@ function clean(o: any, dropDefaults?: boolean): any {
 }
 
 
+
+// The JSON as a Rust RAW string literal.
+//
+// A raw string processes no escapes, so the JSON's own `\n` and `\uXXXX`
+// survive byte for byte and reach the JSON parser as written - which a normal
+// Rust string would not, having consumed them itself. The hash level is raised
+// until its terminator does not occur in the text.
+function rustRawString(s: string): string {
+  let level = 0
+  while (s.includes('"' + '#'.repeat(level))) {
+    level++
+  }
+  const hashes = '#'.repeat(level)
+  return 'r' + hashes + '"' + s + '"' + hashes
+}
+
 export {
+  rustRawString,
   clean,
   crateIdent,
   crateName,

package/project/.sdk/src/cmp/ts/Config_ts.ts

@@ -8,9 +8,13 @@ import {
   Fragment,
   Line,
   cmp,
+  clean,
+  configDefinition,
+  configReprSetting,
   each,
   indent,
   isAuthActive,
+  isConfigData,
   resolveAuthPrefix,
   serverVariables,
 } from '@voxgig/sdkgen'
@@ -25,7 +29,6 @@ import {
 
 
 import {
-  clean,
   formatJson,
 } from './utility_ts'
 
@@ -62,13 +65,58 @@ const Config = cmp(async function Config(props: any) {
     svars.map((v: any) => `      ${JSON.stringify(v.name)}: ${JSON.stringify(v.dflt)},\n`).join('') +
     '    },\n\n    '
 
+  // Read the base URL here rather than leaving it to a `$$...$$` stdrep
+  // placeholder in the fragment. stdrep can only substitute a path the model
+  // actually has: a model with no `info.servers` left the placeholder itself in
+  // the generated source, so `options.base` came out as the literal string
+  // '$main.kit.info.servers.0.url$'. Reading it explicitly yields '' in that
+  // case, which is what every other target already emits, and is identical to
+  // the old output whenever the model does define a server.
+  let baseUrl = ''
+  try {
+    baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
+  } catch (_e) { }
+
+  // The same config as an OBJECT, built by the shared helper so this target's
+  // literal and the data that replaces it above the threshold are the same
+  // config by construction. The JSON is what the threshold is measured on -
+  // emitted source size varies by language, the model does not.
+  const { json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
+
   File({ name: 'Config.' + target.ext }, () => {
 
+    if (asData) {
+      Fragment({
+        from: ff + 'Config.data.fragment.ts',
+
+        replace: {
+
+          '// #ImportFeatures': () => each(feature, (f: any) => {
+            Line(`import { ${nom(f, 'Name')}Feature } from ` +
+              `'./feature/${f.name}/${nom(f, 'Name')}Feature'`)
+          }),
+
+          '// #FeatureClasses': () => each(feature, (f: any) => {
+            Line(` ${f.name}: ${nom(f, 'Name')}Feature,`)
+          }),
+
+          // A JS string literal, so the JSON survives verbatim. JSON.stringify
+          // escapes the quotes and backslashes the model contains (values like
+          // `$STRING` carry backticks, which a template literal could not).
+          "'CONFIGJSON'": JSON.stringify(configJson),
+        }
+      })
+      return
+    }
+
     Fragment({
       from: ff + 'Config.fragment.ts',
 
       replace: {
 
+        "'BASEURL'": JSON.stringify(baseUrl),
+
         "'SERVERBLOCK'": serverBlock,
 
         "'AUTHBLOCK'": authBlock,

package/project/.sdk/src/cmp/ts/fragment/Config.data.fragment.ts

@@ -0,0 +1,50 @@
+
+import { BaseFeature } from './feature/base/BaseFeature'
+// #ImportFeatures
+
+
+const FEATURE_CLASS: Record<string, typeof BaseFeature> = {
+  // #FeatureClasses
+}
+
+
+// THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
+//
+// The literal form of this file declares the whole model as nested object
+// literals on the class. For a large API that is megabytes of source that the
+// TypeScript compiler must parse and infer a type for on every build, and that
+// the JavaScript engine must build node by node on every module load.
+//
+// As a single string constant it is one token to the compiler, and V8's JSON
+// parser builds the object far faster than the equivalent literal - JSON.parse
+// is the well-worn trick for exactly this shape of data.
+//
+// Emitted only above a size threshold, or when `main.kit.config.repr` pins it:
+// for a small model the literal is smaller, loads no slower, and is far easier
+// to read when debugging.
+const CONFIG_DATA = 'CONFIGJSON'
+
+
+class Config {
+
+  makeFeature(this: any, fn: string) {
+    const fc = FEATURE_CLASS[fn]
+    const fi = new fc()
+    // TODO: errors etc
+    return fi
+  }
+
+}
+
+
+// Parsed ONCE, at module load, exactly like the literal form was built once.
+//
+// The parsed data is assigned onto an instance rather than replacing it, so
+// `config.main` / `.feature` / `.options` / `.entity` read exactly as they did
+// when they were field initialisers, and `makeFeature` stays where it was on
+// the prototype. Callers cannot tell which representation they were given.
+const config: any = Object.assign(new Config(), JSON.parse(CONFIG_DATA))
+
+export {
+  config
+}

package/project/.sdk/src/cmp/ts/fragment/Config.fragment.ts

@@ -29,7 +29,7 @@ class Config {
 
 
   options = {
-    base: '$$main.kit.info.servers.0.url$$',
+    base: 'BASEURL',
 
     'SERVERBLOCK''AUTHBLOCK'headers: 'HEADERS',