@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/src/cmp/c/utility_c.ts

@@ -0,0 +1,102 @@
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+// C reserved keywords illegal as identifiers.
+const C_RESERVED = new Set<string>([
+  'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
+  'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline',
+  'int', 'long', 'register', 'restrict', 'return', 'short', 'signed', 'sizeof',
+  'static', 'struct', 'switch', 'typedef', 'union', 'unsigned', 'void',
+  'volatile', 'while', 'bool', 'true', 'false',
+])
+
+
+// A collision-free snake_case C identifier for a model name.
+function cVarName(name: string): string {
+  let snake = String(name).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()
+  if (/^[0-9]/.test(snake)) snake = '_' + snake
+  return C_RESERVED.has(snake) ? snake + '_' : snake
+}
+
+
+// The C project identifier used as a function-name prefix, e.g. solar.
+function cIdent(model: any): string {
+  return String(model.name).toLowerCase().replace(/[^a-z0-9_]/g, '_')
+}
+
+
+// Package-ish name (used in comments only), e.g. voxgig-solar-sdk.
+function cName(model: any): string {
+  const org = (model.origin || 'voxgig-sdk').replace(/-sdk$/, '')
+  return `${org}-${model.name}-sdk`.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+}
+
+
+// Render a JSON-shaped JS value as C source constructing the equivalent
+// voxgig struct Value (the C twin of formatRustValue / formatGoMap). Uses
+// the SDK helper builders declared in sdk.h: cmap / clist / v_str / v_num /
+// v_bool / v_null.
+function formatCValue(val: any, indent: number = 0): string {
+  const pad = '  '.repeat(indent)
+  const padInner = '  '.repeat(indent + 1)
+
+  if (val === null || val === undefined) {
+    return 'v_null()'
+  }
+  if (typeof val === 'string') {
+    return `v_str(${JSON.stringify(val)})`
+  }
+  if (typeof val === 'number') {
+    return `v_num(${Number.isFinite(val) ? val : 0})`
+  }
+  if (typeof val === 'boolean') {
+    return `v_bool(${val})`
+  }
+  if (Array.isArray(val)) {
+    if (val.length === 0) {
+      return 'v_list()'
+    }
+    const items = val
+      .map((v) => padInner + formatCValue(v, indent + 1))
+      .join(',\n')
+    return `clist(${val.length},\n${items})`
+  }
+  if (typeof val === 'object') {
+    const entries = Object.entries(val)
+    if (entries.length === 0) {
+      return 'v_map()'
+    }
+    const items = entries
+      .map(
+        ([k, v]) =>
+          `${padInner}${JSON.stringify(k)}, ${formatCValue(v, indent + 1)}`
+      )
+      .join(',\n')
+    return `cmap(${entries.length},\n${items})`
+  }
+  return `v_str(${JSON.stringify(String(val))})`
+}
+
+
+// Deep-remove meta keys (`foo$`) from a model subtree (twin of go/rust clean).
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && k.endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
+export {
+  clean,
+  cIdent,
+  cName,
+  cVarName,
+  formatCValue,
+}

package/project/.sdk/src/cmp/clojure/Config_clojure.ts

@@ -0,0 +1,94 @@
+
+import {
+  Content,
+  File,
+  cmp,
+  each,
+  isAuthActive,
+  resolveAuthPrefix,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+import {
+  clean,
+  formatCljValue,
+} from './utility_clojure'
+
+
+// sdk/config.clj: make-config builds the embedded API model as a vendored
+// struct value node (LinkedHashMap/ArrayList) via vs/jm and vs/jt. The whole
+// config is assembled as a JSON-shaped object and rendered once through
+// formatCljValue (byte-stable; each() sorted-key iteration + sorted map keys).
+// N-feature-safe: an empty feature/entity map renders as (vs/jm).
+const Config = cmp(async function Config(props: any) {
+  const ctx$ = props.ctx$
+
+  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`) || {}
+
+  const authActive = isAuthActive(model)
+  const authPrefix = resolveAuthPrefix(model)
+
+  let baseUrl = ''
+  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
+
+  const featureConfig: any = {}
+  each(feature, (f: any) => {
+    featureConfig[f.name] = f.config || {}
+  })
+
+  const entityOptions: any = {}
+  each(entity, (ent: any) => {
+    entityOptions[ent.name] = {}
+  })
+
+  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,
+    }), a), {})
+
+  const config = {
+    main: { name: model.const.Name },
+    feature: featureConfig,
+    options,
+    entity: entityConfig,
+  }
+
+  File({ name: 'config.clj' }, () => {
+    Content(`;; ${model.const.Name} SDK configuration (generated by @voxgig/sdkgen).
+(ns sdk.config
+  (:require [voxgig.struct :as vs]))
+
+(defn make-config []
+  ${formatCljValue(config, 1)})
+`)
+  })
+})
+
+
+export {
+  Config
+}

package/project/.sdk/src/cmp/clojure/EntityOperation_clojure.ts

@@ -0,0 +1,35 @@
+
+import {
+  cmp, camelify,
+  Fragment
+} from '@voxgig/sdkgen'
+
+
+const EntityOperation = cmp(function Operation(props: any) {
+  const { model } = props.ctx$
+  const { ff, opname, entity, entrep } = props
+
+  // The op slots sit at top level (Clojure defns), so no indentation is
+  // applied — the marker is a literal key with no captured indent group.
+  let { indent } = props
+  if ('' === indent) {
+    indent = undefined
+  }
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.clj',
+    eject: ['; EJECT-START', '; EJECT-END'],
+    indent,
+    replace: {
+      ...entrep,
+      ProjectName: model.const.Name,
+      EntityName: entity.Name,
+      entityname: entity.name,
+    }
+  })
+})
+
+
+export {
+  EntityOperation
+}

package/project/.sdk/src/cmp/clojure/Entity_clojure.ts

@@ -0,0 +1,77 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, camelify,
+  File, Folder, Fragment,
+} from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import { EntityOperation } from './EntityOperation_clojure'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target, entity } = props
+
+  const entrep = {
+    ...stdrep,
+  }
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/clojure/fragment/')
+
+  // Entity files go to src/sdk/entity/<name>.clj (ns sdk.entity.<name>).
+  Folder({ name: 'src' }, () => {
+    Folder({ name: 'sdk' }, () => {
+      Folder({ name: 'entity' }, () => {
+
+        File({ name: entity.name + '.' + target.ext }, () => {
+
+          const opnames = Object.keys(entity.op)
+
+          // For each CRUD op: splice the real implementation when the spec
+          // defines it; otherwise leave the slot empty (the fn is simply not
+          // defined — callers of an unsupported op get an undefined-var error,
+          // matching the dynamic-language donors).
+          const opfrags =
+            (['load', 'list', 'create', 'update', 'remove']
+              .reduce((a: any, opname: string) =>
+              (a['; #' + camelify(opname) + 'Op'] =
+                !opnames.includes(opname) ? '' : ({ indent }: any) => {
+                  EntityOperation({ ff, opname, indent, entity, entrep })
+                }, a), {}))
+
+          Fragment({
+            from: ff + 'Entity.fragment.clj',
+            replace: {
+              ...entrep,
+              ProjectName: model.const.Name,
+              EntityName: entity.Name,
+              entityname: entity.name,
+
+              // Feature-hook markers. jostraca's built-in `#Name-Tag` pattern
+              // is hardcoded to `//` comments, so Clojure's `; #<Name>-Hook`
+              // marker lines never match it and the pipeline hooks would be
+              // silently dropped. Match the `;`-comment form explicitly.
+              '/(?<indent>[ \\t]*);+[ \\t]*#(?<name>[A-Za-z0-9]+)-Hook[ \\t]*\\n?/':
+                ({ name, indent }: any) =>
+                  `${indent}(core/feature-hook ctx "${name}")\n`,
+
+              ...opfrags,
+            }
+          })
+
+        })
+      })
+    })
+  })
+})
+
+
+export {
+  Entity
+}

package/project/.sdk/src/cmp/clojure/Gitignore_clojure.ts

@@ -0,0 +1,28 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+const Gitignore = cmp(async function Gitignore(_props: any) {
+  File({ name: '.gitignore' }, () => {
+    Content(`# tools.deps / clojure build artifacts
+.cpcache/
+classes/
+target/
+pom.xml
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store
+`)
+  })
+})
+
+
+export {
+  Gitignore
+}

package/project/.sdk/src/cmp/clojure/MainEntity_clojure.ts

@@ -0,0 +1,21 @@
+
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props
+
+  // Public accessor: (<entityname> client data) constructs an entity client.
+  // The accessor name is the (lower-case) entity name; the entity namespace is
+  // aliased e-<name> in the api ns require.
+  Content(`
+;; ${entity.Name} accessor: (${entity.name} client data)
+(defn ${entity.name} [client data] (e-${entity.name}/make client data))
+`)
+})
+
+
+export {
+  MainEntity
+}

package/project/.sdk/src/cmp/clojure/Main_clojure.ts

@@ -0,0 +1,88 @@
+
+import {
+  cmp, each,
+  File, Content, Copy, Folder,
+} from '@voxgig/sdkgen'
+
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+
+import { Package } from './Package_clojure'
+import { Config } from './Config_clojure'
+import { Gitignore } from './Gitignore_clojure'
+import { MainEntity } from './MainEntity_clojure'
+
+
+const Main = cmp(async function Main(props: any) {
+
+  const { target } = props
+  const { model } = props.ctx$
+
+  const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
+
+  Package({ target })
+
+  Gitignore({})
+
+  // Copy tm/clojure verbatim (runtime under src/, the test suite under test/,
+  // Makefile/LICENSE/VERSION). The feature-add scaffolding under src/feature
+  // is excluded — the clojure target does not use per-feature custom source.
+  Copy({
+    from: 'tm/' + target.name,
+    exclude: [/src\/feature\//],
+    replace: {
+      ...props.ctx$.stdrep,
+    }
+  })
+
+  // Generated config namespace (src/sdk/config.clj).
+  Folder({ name: 'src' }, () => {
+    Folder({ name: 'sdk' }, () => {
+      Config({ target })
+    })
+  })
+
+  // Public API namespace (src/sdk/api.clj): entity accessors plus the
+  // re-exported client constructors.
+  Folder({ name: 'src' }, () => {
+    Folder({ name: 'sdk' }, () => {
+      File({ name: 'api.' + target.ext }, () => {
+
+        let requires = ''
+        each(entity, (e: any) => {
+          requires += `\n            [sdk.entity.${e.name} :as e-${e.name}]`
+        })
+
+        Content(`;; ${model.const.Name} SDK public API (generated by @voxgig/sdkgen).
+(ns sdk.api
+  (:require [sdk.client :as client]${requires}))
+
+(def make-sdk client/make-sdk)
+(def test-sdk client/test-sdk)
+(def direct client/direct)
+(def prepare client/prepare)
+(def options-map client/options-map)
+`)
+
+        each(entity, (e: any) => {
+          MainEntity({ target, entity: e })
+        })
+      })
+    })
+  })
+
+})
+
+
+export {
+  Main
+}

package/project/.sdk/src/cmp/clojure/Package_clojure.ts

@@ -0,0 +1,41 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+import type {
+  Model,
+} from '@voxgig/apidef'
+
+
+// deps.edn — the tools.deps manifest. The vendored voxgig struct port needs no
+// external dependency; the library itself only needs org.clojure/clojure. The
+// tools.deps shim used to run the tests supports `-M:alias` reading :paths /
+// :extra-paths / :main-opts, but NOT per-alias :extra-deps, so every dependency
+// lives at the top-level :deps.
+const Package = cmp(async function Package(props: any) {
+  const ctx$ = props.ctx$
+  const model: Model = ctx$.model
+
+  File({ name: 'deps.edn' }, () => {
+    Content(`;; ${model.const.Name} SDK for Clojure (generated by @voxgig/sdkgen).
+{:paths ["src"]
+ :deps {org.clojure/clojure {:mvn/version "1.12.5"}}
+ :aliases
+ {:test
+  {:extra-paths ["test"]
+   :main-opts ["-m" "sdk.test-runner"]}
+  :test-compile
+  {:extra-paths ["test"]
+   :main-opts ["-e" "(require 'sdk.test-runner)(println :ok)"]}}}
+`)
+  })
+})
+
+
+export {
+  Package
+}

package/project/.sdk/src/cmp/clojure/Test_clojure.ts

@@ -0,0 +1,120 @@
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, File, Content, Folder } from '@voxgig/sdkgen'
+
+
+// Generates sdk/gentest.clj (ns sdk.gentest): the API-specific tests, driven by
+// the model. Exposes (run rec) which the template test-runner invokes. Covers
+// entity accessor existence plus a create+list smoke run through the in-memory
+// test-mode mock transport (exercising the full operation pipeline, hooks and
+// run-op for the actual API entities). API-agnostic behaviour (pipeline error
+// branches, all features, netsim, primary utility, struct corpus) lives in the
+// static template test namespaces.
+const Test = cmp(function Test(props: any) {
+  const { model } = props.ctx$
+  const { target } = props
+
+  const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
+  const entities = Object.values(entity) as any[]
+
+  Folder({ name: 'test' }, () => {
+    Folder({ name: 'sdk' }, () => {
+      File({ name: 'gentest.' + target.ext }, () => {
+
+        let requires = ''
+        each(entity, (e: any) => {
+          requires += `\n            [sdk.entity.${e.name} :as e-${e.name}]`
+        })
+
+        Content(`;; ${model.const.Name} SDK generated API tests.
+(ns sdk.gentest
+  (:require [sdk.api :as api]
+            [sdk.config :as config]
+            [sdk.testutil :as t]
+            [voxgig.struct :as vs]${requires}))
+
+(defn run [rec]
+`)
+
+        each(entity, (e: any) => {
+          Content(`  (t/run-check rec "gen-exists-${e.name}"
+    (fn [] (let [sdk (api/test-sdk nil nil)]
+             (t/is-true (some? (api/${e.name} sdk nil)) "${e.name} accessor present"))))
+`)
+        })
+
+        for (const e of entities) {
+          const ops = Object.keys(e.op || {})
+          const hasCreate = ops.includes('create')
+          const hasList = ops.includes('list')
+          if (!hasCreate && !hasList) {
+            continue
+          }
+          Content(`  (t/run-check rec "gen-smoke-${e.name}"
+    (fn [] (let [sdk (api/test-sdk nil nil)
+                 ent (api/${e.name} sdk nil)]
+`)
+          if (hasCreate) {
+            Content(`             (let [res (e-${e.name}/create ent (vs/jm "name" "smoke") nil)]
+               (t/is-true (vs/ismap res) "create returns a record map")
+               (t/is-true (some? (vs/getprop res "id")) "created record has an id"))
+`)
+          }
+          if (hasList) {
+            Content(`             (let [items (e-${e.name}/list ent (vs/jm) nil)]
+               (t/is-true (sequential? items) "list returns a sequential collection"))
+`)
+          }
+          Content(`             )))
+`)
+
+          // PR review #4: entity stream(action, args, callopts). Runs the op
+          // through the full pipeline and returns a lazy seq of items. Seeds
+          // three records via the test mock (SDK.test entity seed) and streams
+          // them; needs only a list op.
+          if (hasList) {
+            Content(`  (t/run-check rec "gen-stream-${e.name}"
+    (fn [] (let [seed (vs/jm "${e.name}" (vs/jm "S1" (vs/jm "id" "S1" "name" "a")
+                                                "S2" (vs/jm "id" "S2" "name" "b")
+                                                "S3" (vs/jm "id" "S3" "name" "c")))]
+             ;; Fallback (no streaming feature): materialised items.
+             (let [sdk (api/test-sdk (vs/jm "entity" seed) nil)
+                   items (vec (e-${e.name}/stream (api/${e.name} sdk nil) "list" (vs/jm) nil))]
+               (t/is-eq (count items) 3 "stream fallback yields materialised items")
+               (t/is-true (vs/ismap (first items)) "stream yields bare record maps"))
+             ;; signal cancels iteration between yields.
+             (let [sdk (api/test-sdk (vs/jm "entity" seed) nil)
+                   n (atom 0) sig (fn [] (>= (swap! n inc) 2))
+                   items (vec (e-${e.name}/stream (api/${e.name} sdk nil) "list" (vs/jm) (vs/jm "signal" sig)))]
+               (t/is-eq (count items) 1 "stream signal stops after first yield"))
+             ;; Streaming feature active: yields from the streaming iterator.
+             (when (vs/getpath (config/make-config) "feature.streaming")
+               (let [ssdk (api/test-sdk (vs/jm "entity" seed) (vs/jm "feature" (vs/jm "streaming" (vs/jm "active" true))))]
+                 (t/is-eq (count (vec (e-${e.name}/stream (api/${e.name} ssdk nil) "list" (vs/jm) nil))) 3
+                          "stream (streaming active) yields all items"))
+               (let [csdk (api/test-sdk (vs/jm "entity" seed) (vs/jm "feature" (vs/jm "streaming" (vs/jm "active" true "chunkSize" 2))))
+                     batches (vec (e-${e.name}/stream (api/${e.name} csdk nil) "list" (vs/jm) nil))]
+                 (t/is-eq (count batches) 2 "stream chunkSize groups items into 2 batches"))))))
+`)
+          }
+        }
+
+        Content(`  nil)
+`)
+      })
+    })
+  })
+})
+
+
+export {
+  Test
+}