@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/src/cmp/ocaml/Package_ocaml.ts

@@ -0,0 +1,47 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+import { packageName } from './utility_ocaml'
+
+
+// <name>.opam — opam package metadata (publish is declared pending in the
+// model; the build itself is stock ocamlc via the Makefile and needs no opam
+// packages). Twin of rust Cargo.toml, but the runtime is dependency-free so
+// there is no depends list beyond the OCaml compiler.
+const Package = cmp(async function Package(props: any) {
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+
+  const pkg = packageName(model)
+
+  File({ name: pkg + '.opam' }, () => {
+    Content(`opam-version: "2.0"
+name: "${pkg}"
+version: "0.0.1"
+synopsis: "${model.const.Name} SDK for OCaml (generated by @voxgig/sdkgen)"
+maintainer: "voxgig"
+authors: "voxgig"
+license: "MIT"
+homepage: "https://voxgig.com"
+bug-reports: "https://voxgig.com"
+# The generated SDK is dependency-free: it compiles with the stock ocamlc
+# (see the Makefile). No opam packages, no dune.
+depends: [
+  "ocaml" {>= "4.14"}
+]
+build: [
+  [make "build"]
+]
+`)
+  })
+})
+
+
+export {
+  Package
+}

package/project/.sdk/src/cmp/ocaml/SdkError_ocaml.ts

@@ -0,0 +1,42 @@
+
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+// sdk_error.ml — a thin API-facing view of the branded SDK error. The error
+// type and exception themselves live in the runtime (Sdk_types.sdk_error /
+// Sdk_error_exc); this module re-exports them under stable names so callers
+// have a single place to catch/inspect errors (twin of rust core/error.rs).
+const SdkError = cmp(async function SdkError(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model = ctx$.model
+
+  File({ name: 'sdk_error.' + target.ext }, () => {
+    Content(`(* ${model.const.Name} SDK error (generated).
+ *
+ * The branded error type and its exception live in the runtime; this module
+ * re-exports them so consumers have one import for error handling:
+ *   try ... with Sdk_error.E err -> Printf.eprintf "%s\\n" err.err_msg *)
+
+open Sdk_types
+
+type t = sdk_error
+
+exception E = Sdk_error_exc
+
+let code (e : t) : string = e.err_code
+let message (e : t) : string = e.err_msg
+`)
+  })
+})
+
+
+export {
+  SdkError
+}

package/project/.sdk/src/cmp/ocaml/TestDirect_ocaml.ts

@@ -0,0 +1,47 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+import { ocamlString } from './utility_ocaml'
+
+
+// Generated per-entity direct-call test: a mock system.fetch records calls and
+// returns a canned response; client.direct issues the raw request and parses
+// the JSON body (mirrors the rust/go TestDirect unit path).
+const TestDirect = cmp(function TestDirect(props: any) {
+  const { target, entity } = props
+
+  File({ name: entity.name + '_direct_test.' + target.ext }, () => {
+
+    Content(`(* Generated ${entity.name} direct-call test. *)
+
+open Voxgig_struct
+open Sdk_types
+open Sdk_helpers
+open Testutil
+
+let () =
+  test "${ocamlString(entity.name)}.direct_call" (fun () ->
+      let calls = ref [] in
+      let mock = Func (fun _ args _ _ ->
+          calls := !calls @ [args];
+          jo [("status", Num 200.); ("statusText", Str "OK"); ("headers", empty_map ());
+              ("json", json_thunk (jo [("id", Str "direct01")]))]) in
+      let client = Sdk_client.make
+          (jo [("base", Str "http://localhost:8080"); ("system", jo [("fetch", mock)])]) in
+      let result = Sdk_client.direct client
+          (jo [("path", Str "/${ocamlString(entity.name)}"); ("method", Str "GET")]) in
+      check_vbool "ok" (getp result "ok") true;
+      check_vstr "data.id" (getp (getp result "data") "id") "direct01";
+      check_int "one call" (List.length !calls) 1)
+`)
+  })
+})
+
+
+export {
+  TestDirect
+}

package/project/.sdk/src/cmp/ocaml/TestEntity_ocaml.ts

@@ -0,0 +1,130 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+import { ocamlString, ocamlVarName } from './utility_ocaml'
+
+
+// Generated per-entity test: the accessor yields an entity with the right
+// name, and (test mode) the present read ops round-trip through the full
+// pipeline against seeded mock data (list returns the seeded record; load by
+// id returns it). Mirrors the intent of the rust/go TestEntity flow, but
+// self-contained (inline seed, no external fixture).
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { target, entity } = props
+
+  const fn = ocamlVarName(entity.name)
+  const opnames = Object.keys(entity.op || {})
+  const hasList = opnames.includes('list')
+  const hasLoad = opnames.includes('load')
+  const hasId = null != entity.id
+  const id = entity.name + '01'
+
+  File({ name: entity.name + '_entity_test.' + target.ext }, () => {
+
+    Content(`(* Generated ${entity.name} entity test. *)
+
+open Voxgig_struct
+open Sdk_types
+open Sdk_helpers
+open Testutil
+
+let () =
+  test "${ocamlString(entity.name)}.entity_instance" (fun () ->
+      let client = Sdk_client.test () in
+      let ent = Sdk_client.${fn} client Noval in
+      check_str "name" ent.e_name "${ocamlString(entity.name)}")
+`)
+
+    // Seeded test-mode round-trip: the test feature builds an in-memory mock
+    // from options.entity, so a seeded record is loadable/listable.
+    if (hasList || hasLoad) {
+      Content(`
+let () =
+  test "${ocamlString(entity.name)}.seeded_ops" (fun () ->
+      let record = jo [("id", Str "${ocamlString(id)}")] in
+      let seed = jo [("${ocamlString(entity.name)}",
+                      jo [("${ocamlString(id)}", record)])] in
+      let client = Sdk_client.test_with (jo [("entity", seed)]) Noval in
+      let ent = Sdk_client.${fn} client Noval in
+      ignore ent;
+`)
+      if (hasList) {
+        Content(`      let listed = ent.e_list (empty_map ()) Noval in
+      check "list is a list" (islist listed);
+      check_int "list size" (size listed) 1;
+`)
+      }
+      if (hasLoad) {
+        Content(`      let loaded = ent.e_load (jo [("id", Str "${ocamlString(id)}")]) Noval in
+      check "load is a map" (ismap loaded);
+`)
+        if (hasId) {
+          Content(`      check_vstr "load id" (getp loaded "id") "${ocamlString(id)}";
+`)
+        }
+      }
+      Content(`      ())
+`)
+    }
+
+    // PR review #4: entity e_stream(action, args, callopts) runs the op through
+    // the full pipeline and returns a lazy Seq. Fallback (no streaming feature)
+    // yields the materialised items; with the streaming feature active it yields
+    // from the streaming iterator (chunkSize groups into batches). Needs a list
+    // op with seeded data.
+    if (hasList) {
+      Content(`
+let () =
+  test "${ocamlString(entity.name)}.stream" (fun () ->
+      let mk_seed () =
+        jo [("${ocamlString(entity.name)}",
+             jo [("S1", jo [("id", Str "S1"); ("name", Str "a")]);
+                 ("S2", jo [("id", Str "S2"); ("name", Str "b")]);
+                 ("S3", jo [("id", Str "S3"); ("name", Str "c")])])] in
+      let has_streaming =
+        not (is_nullish (getp (getp (Sdk_config.make_config ()) "feature") "streaming")) in
+
+      (* Fallback (no streaming feature): materialised items. *)
+      let client = Sdk_client.test_with (jo [("entity", mk_seed ())]) Noval in
+      let ent = Sdk_client.${fn} client Noval in
+      let items = List.of_seq (ent.e_stream "list" (empty_map ()) Noval) in
+      check_int "stream fallback count" (List.length items) 3;
+      check "stream yields record maps" (ismap (List.hd items));
+
+      (* signal cancels iteration between yields. *)
+      let client2 = Sdk_client.test_with (jo [("entity", mk_seed ())]) Noval in
+      let ent2 = Sdk_client.${fn} client2 Noval in
+      let n = ref 0 in
+      let sig_ = vfunc0 (fun () -> incr n; Bool (!n >= 2)) in
+      let items2 = List.of_seq (ent2.e_stream "list" (empty_map ()) (jo [("signal", sig_)])) in
+      check_int "stream signal stops after first" (List.length items2) 1;
+
+      if has_streaming then begin
+        (* Streaming feature active: yields from the streaming iterator. *)
+        let sfeat = jo [("feature", jo [("streaming", jo [("active", Bool true)])])] in
+        let sclient = Sdk_client.test_with (jo [("entity", mk_seed ())]) sfeat in
+        let sent = Sdk_client.${fn} sclient Noval in
+        check_int "stream (streaming active) count"
+          (List.length (List.of_seq (sent.e_stream "list" (empty_map ()) Noval))) 3;
+
+        (* chunkSize groups items into batches: 3 items / 2 -> 2 batches. *)
+        let cfeat = jo [("feature", jo [("streaming",
+                          jo [("active", Bool true); ("chunkSize", Num 2.)])])] in
+        let cclient = Sdk_client.test_with (jo [("entity", mk_seed ())]) cfeat in
+        let cent = Sdk_client.${fn} cclient Noval in
+        check_int "stream chunkSize batch count"
+          (List.length (List.of_seq (cent.e_stream "list" (empty_map ()) Noval))) 2
+      end)
+`)
+    }
+  })
+})
+
+
+export {
+  TestEntity
+}

package/project/.sdk/src/cmp/ocaml/Test_ocaml.ts

@@ -0,0 +1,35 @@
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, Folder } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_ocaml'
+import { TestDirect } from './TestDirect_ocaml'
+
+
+const Test = cmp(function Test(props: any) {
+  const { model } = props.ctx$
+  const { target } = props
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+
+  Folder({ name: 'test' }, () => {
+    each(entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity })
+      TestDirect({ target, entity })
+    })
+  })
+})
+
+
+export {
+  Test
+}

package/project/.sdk/src/cmp/ocaml/fragment/RunOp.fragment.ml

@@ -0,0 +1,32 @@
+(* Run the operation pipeline, firing feature hooks between stages via the
+ * generated hook-marker lines. post_done runs after the PreDone stage, just
+ * before done. Errors from any stage go through make_error (which either
+ * returns resdata when throw is disabled, or raises). *)
+let run_op (ctx : ctx) (post_done : unit -> unit) : value =
+  let utility = cu ctx in
+  let bail (err : sdk_error option) = raise (Op_return (utility.u_make_error ctx err)) in
+  try
+    (try
+       (* #PrePoint-Hook *)
+       let point = (match utility.u_make_point ctx with (p, None) -> p | (_, e) -> bail e) in
+       Hashtbl.replace ctx.c_out "point" (OPoint point);
+       (* #PreSpec-Hook *)
+       let spec = (match utility.u_make_spec ctx with (Some s, None) -> s | (_, e) -> bail e) in
+       Hashtbl.replace ctx.c_out "spec" (OSpec spec);
+       (* #PreRequest-Hook *)
+       let resp = (match utility.u_make_request ctx with (Some r, None) -> r | (_, e) -> bail e) in
+       Hashtbl.replace ctx.c_out "request" (OResponse resp);
+       (* #PreResponse-Hook *)
+       let resp2 = (match utility.u_make_response ctx with (Some r, None) -> r | (_, e) -> bail e) in
+       Hashtbl.replace ctx.c_out "response" (OResponse resp2);
+       (* #PreResult-Hook *)
+       let result = (match utility.u_make_result ctx with (Some r, None) -> r | (_, e) -> bail e) in
+       Hashtbl.replace ctx.c_out "result" (OResult result);
+       (* #PreDone-Hook *)
+       post_done ();
+       utility.u_done ctx
+     with Op_return v -> v)
+  with
+  | Sdk_error_exc _ as e ->
+    (* #PreUnexpected-Hook *)
+    raise e

package/project/.sdk/src/cmp/ocaml/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2022",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}

package/project/.sdk/src/cmp/ocaml/utility_ocaml.ts

@@ -0,0 +1,129 @@
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+// OCaml keywords that are illegal as a lowercase identifier. sdkgen's shared
+// safeVarName has no ocaml entry, so the guard lives here.
+const OCAML_RESERVED = new Set<string>([
+  'and', 'as', 'assert', 'asr', 'begin', 'class', 'constraint', 'do', 'done',
+  'downto', 'else', 'end', 'exception', 'external', 'false', 'for', 'fun',
+  'function', 'functor', 'if', 'in', 'include', 'inherit', 'initializer',
+  'land', 'lazy', 'let', 'lor', 'lsl', 'lsr', 'lxor', 'match', 'method', 'mod',
+  'module', 'mutable', 'new', 'nonrec', 'object', 'of', 'open', 'or', 'private',
+  'rec', 'sig', 'struct', 'then', 'to', 'true', 'try', 'type', 'val', 'virtual',
+  'when', 'while', 'with',
+])
+
+
+// A collision-free snake_case OCaml (lowercase) identifier for a model name.
+function ocamlVarName(name: string): string {
+  let snake = String(name).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()
+  if ('' === snake || !/^[a-z_]/.test(snake)) {
+    snake = '_' + snake
+  }
+  return OCAML_RESERVED.has(snake) ? snake + '_' : snake
+}
+
+
+// The generated per-entity module basename (module Sdk_entity_<name>).
+function entityModule(name: string): string {
+  return 'sdk_entity_' + ocamlVarName(name)
+}
+
+
+// The opam / distribution package name, e.g. voxgig-solar-sdk (mirrors the go
+// module naming: org prefix from model.origin).
+function packageName(model: any): string {
+  const org = (model.origin || 'voxgig-sdk').replace(/-sdk$/, '')
+  return `${org}-${model.name}-sdk`.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+}
+
+
+// Escape a JS string as an OCaml string literal body (byte string). OCaml
+// accepts `\\`, `\"`, `\n`, `\r`, `\t` and decimal `\ddd` escapes; other bytes
+// (incl. UTF-8) pass through literally.
+function ocamlString(s: string): string {
+  let out = ''
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i]
+    const code = s.charCodeAt(i)
+    if ('\\' === c) out += '\\\\'
+    else if ('"' === c) out += '\\"'
+    else if ('\n' === c) out += '\\n'
+    else if ('\r' === c) out += '\\r'
+    else if ('\t' === c) out += '\\t'
+    else if (code < 0x20) out += '\\' + String(code).padStart(3, '0')
+    else out += c
+  }
+  return out
+}
+
+
+// Render a JSON-shaped JS value as OCaml source constructing the equivalent
+// voxgig struct `value` (the OCaml twin of go's formatGoMap / rust's
+// formatRustValue). Uses the sdk_helpers `jo`/`ja` builders.
+function formatOcamlValue(val: any, indent: number = 0): string {
+  const pad = '  '.repeat(indent)
+  const padInner = '  '.repeat(indent + 1)
+
+  if (null === val || undefined === val) {
+    return 'Null'
+  }
+  if ('string' === typeof val) {
+    return `(Str "${ocamlString(val)}")`
+  }
+  if ('number' === typeof val) {
+    const n = Number.isInteger(val) ? val + '.' : String(val)
+    return `(Num (${n}))`
+  }
+  if ('boolean' === typeof val) {
+    return `(Bool ${val})`
+  }
+  if (Array.isArray(val)) {
+    if (0 === val.length) {
+      return '(empty_list ())'
+    }
+    const items = val
+      .map((v) => padInner + formatOcamlValue(v, indent + 1))
+      .join(';\n')
+    return `(ja [\n${items} ])`
+  }
+  if ('object' === typeof val) {
+    const entries = Object.entries(val)
+    if (0 === entries.length) {
+      return '(empty_map ())'
+    }
+    const items = entries
+      .map(
+        ([k, v]) =>
+          `${padInner}("${ocamlString(k)}", ${formatOcamlValue(v, indent + 1)})`
+      )
+      .join(';\n')
+    return `(jo [\n${items} ])`
+  }
+  return `(Str "${ocamlString(String(val))}")`
+}
+
+
+// Deep-remove meta keys (`foo$`) from a model subtree (twin of go's clean).
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && String(k).endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
+export {
+  clean,
+  entityModule,
+  formatOcamlValue,
+  ocamlString,
+  ocamlVarName,
+  packageName,
+}

package/project/.sdk/src/cmp/perl/Config_perl.ts

@@ -0,0 +1,127 @@
+
+import {
+  Content,
+  File,
+  cmp,
+  each,
+  isAuthActive,
+  resolveAuthPrefix,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+import {
+  clean,
+} from './utility_perl'
+
+
+// The config is emitted as a JSON heredoc parsed at load time by the
+// vendored struct utility (Voxgig::Struct::parse_json). This keeps
+// booleans/nulls faithful (Perl has no native boolean scalar) and yields
+// insertion-ordered maps - and stays N-feature-safe: any number of
+// features simply serialize into the "feature" block.
+const Config = cmp(async function Config(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  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)
+  // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
+  const authPrefix = resolveAuthPrefix(model)
+
+  let baseUrl = ''
+  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
+
+  // Build the config structure with deterministic (sorted) key order for
+  // the model-derived collections (each() iterates sorted).
+  const featureBlock: any = {}
+  each(feature, (f: any) => {
+    featureBlock[f.name] = clean(f.config || {})
+  })
+
+  const entityOptions: any = {}
+  each(entity, (ent: any) => {
+    entityOptions[ent.name] = {}
+  })
+
+  const entityBlock: any = {}
+  each(entity, (ent: any) => {
+    entityBlock[ent.name] = clean({
+      fields: ent.fields,
+      name: ent.name,
+      op: ent.op,
+      relations: ent.relations,
+    })
+  })
+
+  const options: any = {
+    base: baseUrl,
+  }
+  if (authActive) {
+    options.auth = { prefix: authPrefix }
+  }
+  options.headers = headers
+  options.entity = entityOptions
+
+  const config = {
+    main: { name: model.const.Name },
+    feature: featureBlock,
+    options,
+    entity: entityBlock,
+  }
+
+  const configJson = JSON.stringify(config, null, 2)
+
+  File({ name: 'config.pm' }, () => {
+
+    Content(`# ${model.const.Name} SDK configuration
+
+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"));
+
+package ${model.const.Name}Config;
+
+# GENERATED from the API model - do not edit by hand. Parsed fresh on
+# each call so callers can safely mutate their copy.
+my $CONFIG_JSON = <<'END_CONFIG_JSON';
+${configJson}
+END_CONFIG_JSON
+
+sub make_config {
+  return Voxgig::Struct::parse_json($CONFIG_JSON);
+}
+
+sub make_feature {
+  my ($name) = @_;
+  require(Cwd::abs_path("$__dir/features.pm"));
+  return ${model.const.Name}Features::make_feature($name);
+}
+
+1;
+`)
+  })
+})
+
+
+export {
+  Config
+}

package/project/.sdk/src/cmp/perl/EntityOperation_perl.ts

@@ -0,0 +1,42 @@
+
+import {
+  cmp, camelify,
+  Content, Fragment
+} from '@voxgig/sdkgen'
+
+
+const EntityOperation = cmp(function Operation(props: any) {
+  const { model } = props.ctx$
+  const { ff, opname, entity, entrep } = props
+
+  let { indent } = props
+
+  if (null != indent) {
+    indent = indent.substring(1)
+    if ('' == indent) {
+      indent = undefined
+    }
+  }
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.pm',
+    eject: ['# EJECT-START', '# EJECT-END'],
+    indent,
+    replace: {
+      ...entrep,
+      ProjectName: model.const.Name,
+      EntityName: entity.Name,
+      entityname: entity.name,
+      '#Feature-Hook': ({ name, indent }: any) =>
+        Content({ indent }, `
+$utility->{feature_hook}->($ctx, "${name}");
+`)
+
+    }
+  })
+})
+
+
+export {
+  EntityOperation
+}