@voxgig/sdkgen 3.4.5 → 3.4.7

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,6 +8,9 @@ import {
   Fragment,
   Line,
   cmp,
+  clean,
+  configDefinition,
+  configReprSetting,
   each,
   indent,
   isAuthActive,
@@ -26,7 +29,6 @@ import {
 
 
 import {
-  clean,
   formatJson,
 } from './utility_ts'
 
@@ -75,58 +77,16 @@ const Config = cmp(async function Config(props: any) {
     baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
   } catch (_e) { }
 
-  // The same config as an OBJECT, so it can be measured and, above the
-  // threshold, emitted as data instead of as class field literals. Mirrors the
-  // literal branch below exactly - feature config is NOT cleaned here, because
-  // it is not cleaned there either.
-  const entityDefs: any = {}
-  each(entity, (e: any) => {
-    entityDefs[e.name] = clean({
-      fields: e.fields,
-      name: e.name,
-      op: e.op,
-      relations: e.relations,
-    }, true)
-  })
-
-  const featureDefs: any = {}
-  each(feature, (f: any) => {
-    featureDefs[f.name] = f.config
-  })
-
-  const entityStubs: any = {}
-  each(entity, (e: any) => {
-    entityStubs[e.name] = {}
-  })
-
-  const optionsDef: any = { base: baseUrl }
-  if (0 < svars.length) {
-    optionsDef.server = svars.reduce(
-      (a: any, v: any) => (a[v.name] = v.dflt, a), {})
-  }
-  if (authActive) {
-    optionsDef.auth = { prefix: authPrefix }
-  }
-  optionsDef.headers = headers
-  optionsDef.entity = entityStubs
-
-  const configDef = {
-    main: { name: model.const.Name },
-    feature: featureDefs,
-    options: optionsDef,
-    entity: entityDefs,
-  }
-  const configJson = JSON.stringify(configDef)
-
-  // `auto` decides by size; 'data'/'literal' pin it for this SDK.
-  let configReprSetting = 'auto'
-  try {
-    configReprSetting = getModelPath(model, `main.${KIT}.config.repr`) || 'auto'
-  } 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 (isConfigData(configJson, configReprSetting)) {
+    if (asData) {
       Fragment({
         from: ff + 'Config.data.fragment.ts',
 

package/project/.sdk/src/cmp/zig/Config_zig.ts

@@ -3,9 +3,11 @@ import {
   Content,
   File,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
-  resolveAuthPrefix,
+  isConfigData,
 } from '@voxgig/sdkgen'
 
 
@@ -17,7 +19,6 @@ import {
 
 
 import {
-  clean,
   formatZigValue,
 } from './utility_zig'
 
@@ -31,52 +32,57 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  const entity = getModelPath(model, `main.${KIT}.entity`)
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
-  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
+  // 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 authActive = isAuthActive(model)
-  const authPrefix = resolveAuthPrefix(model)
+  File({ name: 'config.' + target.ext }, () => {
 
-  let baseUrl = ''
-  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // The literal is one nested expression that Zig's comptime evaluator has
+    // to walk in full at every build; a string constant is one token, and
+    // `json_parse` (std.json at the boundary, then fromStdJson) builds the
+    // same Value at runtime.
+    //
+    // The escaping is JSON.stringify's, which is valid Zig: it escapes every
+    // backslash, so the JSON's own `\uXXXX` reaches the file as `\\uXXXX` and
+    // no Zig escape sequence is ever formed from it.
+    if (asData) {
+      Content(`// Generated API configuration (mirrors go/rust core/config).
 
-  const featureConfig: any = {}
-  each(feature, (f: any) => {
-    featureConfig[f.name] = f.config || {}
-  })
+const std = @import("std");
+const h = @import("helpers.zig");
+const types = @import("types.zig");
+const jsonparse = @import("../utility/jsonparse.zig");
+const Value = h.Value;
+const Feature = types.Feature;
 
-  const entityOptions: any = {}
-  each(entity, (ent: any) => {
-    entityOptions[ent.name] = {}
-  })
+/// 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: []const u8 = ${JSON.stringify(configJson)};
 
-  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,
-  }
+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.
+    return jsonparse.json_parse(CONFIG_DATA) catch
+        @panic("${model.const.Name}: embedded config is not valid JSON");
+}
 
-  File({ name: 'config.' + target.ext }, () => {
+pub fn make_feature(name: []const u8) Feature {
+`)
+    }
+    else {
 
     Content(`// Generated API configuration (mirrors go/rust core/config).
 
@@ -92,6 +98,7 @@ pub fn make_config() Value {
 
 pub fn make_feature(name: []const u8) Feature {
 `)
+    }
 
     // The factory must be able to instantiate any built-in feature by name,
     // not just the ones the current API model configures — a caller can enable