@voxgig/sdkgen 1.3.8 → 1.3.10

package/project/.sdk/src/cmp/elixir/Entity_elixir.ts

@@ -0,0 +1,54 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, camelify,
+  File, Folder, Fragment,
+} from '@voxgig/sdkgen'
+
+
+import { EntityOperation } from './EntityOperation_elixir'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target, entity } = props
+
+  const Name = model.const.Name
+  const entrep = { ...stdrep }
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/elixir/fragment/')
+
+  Folder({ name: 'lib' }, () => {
+    Folder({ name: 'entity' }, () => {
+      File({ name: entity.name + '_entity.' + target.ext }, () => {
+
+        const opnames = Object.keys(entity.op)
+
+        const opfrags =
+          (['load', 'list', 'create', 'update', 'remove']
+            .reduce((a: any, opname: string) =>
+            (a['# #' + camelify(opname) + 'Op'] =
+              !opnames.includes(opname) ? '' : (_slot: any) => {
+                EntityOperation({ ff, opname, entity, entrep })
+              }, a), {}))
+
+        Fragment({
+          from: ff + 'Entity.fragment.ex',
+          replace: {
+            ...entrep,
+            ProjectName: Name,
+            EntityName: entity.Name,
+            entityname: entity.name,
+            ...opfrags,
+          }
+        })
+      })
+    })
+  })
+})
+
+
+export {
+  Entity
+}

package/project/.sdk/src/cmp/elixir/Gitignore_elixir.ts

@@ -0,0 +1,28 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+const Gitignore = cmp(function Gitignore(_props: any) {
+  File({ name: '.gitignore' }, () => {
+    Content(`/_build/
+/cover/
+/deps/
+/doc/
+/.fetch
+erl_crash.dump
+*.ez
+*.beam
+/config/*.secret.exs
+.elixir_ls/
+`)
+  })
+})
+
+
+export {
+  Gitignore
+}

package/project/.sdk/src/cmp/elixir/MainEntity_elixir.ts

@@ -0,0 +1,26 @@
+
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+// Emit an entity factory function into the main SDK module (at its slot):
+//   def widget(client, entopts \\ nil), do: Solardemo.Entity.Widget.new(client, entopts)
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props
+  const { model } = props.ctx$
+
+  const Name = model.const.Name
+
+  Content(`
+  @doc "Entity factory for ${entity.name}."
+  def ${entity.name}(client, entopts \\\\ nil) do
+    ${Name}.Entity.${entity.Name}.new(client, entopts)
+  end
+`)
+
+})
+
+
+export {
+  MainEntity
+}

package/project/.sdk/src/cmp/elixir/Main_elixir.ts

@@ -0,0 +1,124 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each,
+  File, Folder, Content, Copy, Fragment,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+import { Package } from './Package_elixir'
+import { Config } from './Config_elixir'
+import { Gitignore } from './Gitignore_elixir'
+import { MainEntity } from './MainEntity_elixir'
+
+
+// #`-comment hook marker key (gotcha #1: jostraca's built-in #Name-Tag
+// replacement only matches `//` comments, so an Elixir `# #<Name>-Hook`
+// line never matches and the pipeline hook would be silently dropped).
+const HOOK_KEY =
+  '/(?<indent>[ \\t]*)#[ \\t]*#(?<name>[A-Za-z0-9]+)-Hook[ \\t]*\\n?/'
+
+
+function cap(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+
+const Main = cmp(async function Main(props: any) {
+  const { target } = props
+  const { model, stdrep } = props.ctx$
+
+  const Name = model.const.Name
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const feature = getModelPath(model, `main.${KIT}.feature`)
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/elixir/fragment/')
+
+  Package({ target })
+  Gitignore({})
+
+  // Copy tm/elixir verbatim (with ProjectName/projectname substitution).
+  Copy({
+    from: 'tm/' + target.name,
+    exclude: [/src\//],
+    replace: {
+      ...stdrep,
+    }
+  })
+
+  Folder({ name: 'lib' }, () => {
+
+    // Main SDK module (entity factory fns injected at the slot).
+    File({ name: model.const.name + '.' + target.ext }, () => {
+      Fragment(
+        {
+          from: ff + 'Main.fragment.ex',
+          replace: {
+            ...stdrep,
+            ProjectName: Name,
+          }
+        },
+        () => {
+          each(entity, (ent: any) => {
+            MainEntity({ target, entity: ent })
+          })
+        }
+      )
+    })
+
+    // Operation pipeline (hook markers replaced here — gotcha #1).
+    File({ name: 'pipeline.' + target.ext }, () => {
+      Fragment({
+        from: ff + 'Pipeline.fragment.ex',
+        replace: {
+          ...stdrep,
+          ProjectName: Name,
+          [HOOK_KEY]: ({ name, indent }: any) =>
+            `${indent}Utility.feature_hook(ctx, "${name}")\n`,
+        }
+      })
+    })
+
+    // Feature factory.
+    File({ name: 'features.' + target.ext }, () => {
+      Content(`# ${Name} SDK feature factory
+
+defmodule ${Name}.Features do
+  def make_feature(name) do
+    case name do
+`)
+
+      each(feature, (f: any) => {
+        if (f.name === 'base') {
+          Content(`      "base" -> ${Name}.Feature.new()
+`)
+        }
+        else {
+          Content(`      ${JSON.stringify(f.name)} -> ${Name}.Feature.${cap(f.name)}.new()
+`)
+        }
+      })
+
+      Content(`      _ -> ${Name}.Feature.new()
+    end
+  end
+end
+`)
+    })
+  })
+
+  // Config module.
+  Config({ target })
+})
+
+
+export {
+  Main
+}

package/project/.sdk/src/cmp/elixir/Package_elixir.ts

@@ -0,0 +1,64 @@
+
+import {
+  Content,
+  File,
+  cmp,
+  pkgDescription,
+  repoInfo,
+} from '@voxgig/sdkgen'
+
+
+import type {
+  Model,
+} from '@voxgig/apidef'
+
+
+// Generate mix.exs for the Elixir SDK. The vendored struct library has zero
+// third-party runtime deps, so the SDK ships with none either.
+const Package = cmp(async function Package(props: any) {
+  const ctx$ = props.ctx$
+  const model: Model = ctx$.model
+
+  const Name = model.const.Name
+  const app = model.const.name
+  const { repoUrl } = repoInfo(model)
+
+  File({ name: 'mix.exs' }, () => {
+    Content(`defmodule ${Name}.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :${app},
+      version: "0.0.1",
+      elixir: "~> 1.14",
+      description: ${JSON.stringify(pkgDescription(model, 'elixir'))},
+      elixirc_paths: elixirc_paths(Mix.env()),
+      start_permanent: Mix.env() == :prod,
+      deps: deps(),
+      package: package()
+    ]
+  end
+
+  def application, do: [extra_applications: [:inets, :ssl]]
+
+  defp deps, do: []
+
+  defp elixirc_paths(:test), do: ["lib", "test/support"]
+  defp elixirc_paths(_), do: ["lib"]
+
+  defp package do
+    [
+      licenses: ["MIT"],
+      links: %{"Homepage" => ${JSON.stringify(repoUrl)}}
+    ]
+  end
+end
+`)
+  })
+})
+
+
+export {
+  Package
+}

package/project/.sdk/src/cmp/elixir/TestDirect_elixir.ts

@@ -0,0 +1,95 @@
+
+import {
+  Model,
+  ModelEntity,
+} from '@voxgig/apidef'
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+// Emit a per-entity direct() test: a live-mode SDK wired to a recording
+// mock system.fetch, exercising the raw-HTTP escape hatch.
+const TestDirect = cmp(function TestDirect(props: any) {
+  const { model }: { model: Model } = props.ctx$
+  const target = props.target
+  const entity: ModelEntity = props.entity
+
+  const Name = model.const.Name
+  const EName = entity.Name
+  const ename = entity.name
+
+  const opnames = Object.keys(entity.op || {})
+  const hasLoad = opnames.includes('load')
+  const hasList = opnames.includes('list')
+
+  if (!hasLoad && !hasList) {
+    return
+  }
+
+  File({ name: ename + '_direct_test.exs' }, () => {
+
+    Content(`# ${EName} direct test (offline, mock system.fetch)
+
+defmodule ${Name}.${EName}DirectTest do
+  use ExUnit.Case
+
+  alias Voxgig.Struct, as: S
+  alias ${Name}.Helpers, as: H
+
+  # A recording live-mode SDK whose transport returns \`canned\`.
+  defp mk(canned) do
+    parent = self()
+
+    fetch = fn url, _fetchdef ->
+      send(parent, {:called, url})
+      {S.jm(["status", 200, "statusText", "OK", "headers", S.jm([]), "json", fn -> canned end, "body", "mock"]), nil}
+    end
+
+    ${Name}.new(S.jm(["base", "http://localhost:8080", "system", S.jm(["fetch", fetch])]))
+  end
+`)
+
+    if (hasList) {
+      Content(`
+  test "should direct list ${ename}" do
+    canned = S.jt([S.jm(["id", "direct01"]), S.jm(["id", "direct02"])])
+    sdk = mk(canned)
+    res = ${Name}.direct(sdk, H.deep(%{"path" => "/${ename}", "method" => "GET", "params" => %{}}))
+    assert S.getprop(res, "ok") == true
+    assert H.to_int(S.getprop(res, "status")) == 200
+    assert S.islist(S.getprop(res, "data"))
+    assert S.size(S.getprop(res, "data")) == 2
+    assert_received {:called, _url}
+  end
+`)
+    }
+
+    if (hasLoad) {
+      Content(`
+  test "should direct load ${ename}" do
+    canned = S.jm(["id", "direct01"])
+    sdk = mk(canned)
+    res = ${Name}.direct(sdk, H.deep(%{"path" => "/${ename}/direct01", "method" => "GET", "params" => %{}}))
+    assert S.getprop(res, "ok") == true
+    assert H.to_int(S.getprop(res, "status")) == 200
+    data = S.getprop(res, "data")
+    assert S.ismap(data)
+    assert S.getprop(data, "id") == "direct01"
+    assert_received {:called, _url}
+  end
+`)
+    }
+
+    Content(`end
+`)
+  })
+})
+
+
+export {
+  TestDirect
+}

package/project/.sdk/src/cmp/elixir/TestEntity_elixir.ts

@@ -0,0 +1,115 @@
+
+import {
+  KIT,
+  Model,
+  ModelEntity,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+// Emit a per-entity ExUnit test that drives the real op pipeline against the
+// `test` feature's in-memory mock, seeded from the scaffolded fixture
+// (../.sdk/test/entity/<Name>/<Name>TestData.json -> existing.<entity>).
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { model }: { model: Model } = props.ctx$
+  const target = props.target
+  const entity: ModelEntity = props.entity
+
+  const Name = model.const.Name
+  const EName = entity.Name
+  const ename = entity.name
+
+  const opnames = Object.keys(entity.op || {})
+  const hasLoad = opnames.includes('load')
+  const hasList = opnames.includes('list')
+  const hasCreate = opnames.includes('create')
+
+  const fixture = `../.sdk/test/entity/${ename}/${EName}TestData.json`
+
+  File({ name: ename + '_entity_test.exs' }, () => {
+
+    Content(`# ${EName} entity test (offline, mock transport)
+
+defmodule ${Name}.${EName}EntityTest do
+  use ExUnit.Case
+
+  alias Voxgig.Struct, as: S
+  alias ${Name}.Helpers, as: H
+  alias ${Name}.Json
+
+  defp fixture do
+    Json.parse(File.read!(${JSON.stringify(fixture)}))
+  end
+
+  defp mk_sdk do
+    existing = H.or_(S.getpath(fixture(), "existing"), S.jm([]))
+    ${Name}.test(S.jm(["entity", existing]))
+  end
+
+  defp first_id do
+    existing = H.or_(S.getpath(fixture(), "existing.${ename}"), S.jm([]))
+    keys = S.keysof(existing)
+    if keys == [], do: nil, else: hd(keys)
+  end
+
+  test "should create instance" do
+    sdk = ${Name}.test()
+    ent = ${Name}.${ename}(sdk)
+    assert ent != nil
+  end
+`)
+
+    if (hasList) {
+      Content(`
+  test "should list records" do
+    sdk = mk_sdk()
+    ent = ${Name}.${ename}(sdk)
+    result = ${Name}.Entity.${EName}.list(ent, S.jm([]))
+    assert S.islist(result)
+  end
+`)
+    }
+
+    if (hasLoad) {
+      Content(`
+  test "should load an existing record" do
+    id = first_id()
+
+    if id != nil do
+      sdk = mk_sdk()
+      ent = ${Name}.${ename}(sdk)
+      rec = ${Name}.Entity.${EName}.load(ent, S.jm(["id", id]))
+      assert S.ismap(rec)
+      assert S.getprop(rec, "id") == id
+    end
+  end
+`)
+    }
+
+    if (hasCreate) {
+      Content(`
+  test "should create then read back" do
+    sdk = ${Name}.test(S.jm(["entity", S.jm(["${ename}", S.jm([])])]))
+    ent = ${Name}.${ename}(sdk)
+    made = ${Name}.Entity.${EName}.create(ent, S.jm(["name", "test-create"]))
+    assert S.ismap(made)
+    assert S.getprop(made, "id") != nil
+  end
+`)
+    }
+
+    Content(`end
+`)
+  })
+})
+
+
+export {
+  TestEntity
+}

package/project/.sdk/src/cmp/elixir/Test_elixir.ts

@@ -0,0 +1,47 @@
+
+import {
+  KIT,
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_elixir'
+import { TestDirect } from './TestDirect_elixir'
+
+
+const Test = cmp(function Test(props: any) {
+  const { model } = props.ctx$
+  const { target } = props
+
+  const Name = model.const.Name
+
+  Folder({ name: 'test' }, () => {
+
+    File({ name: 'exists_test.exs' }, () => {
+      Content(`defmodule ${Name}.ExistsTest do
+  use ExUnit.Case
+
+  test "should create test sdk" do
+    testsdk = ${Name}.test()
+    assert testsdk != nil
+  end
+end
+`)
+    })
+
+    each(model.main[KIT].entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity })
+      TestDirect({ target, entity })
+    })
+  })
+})
+
+
+export {
+  Test
+}

package/project/.sdk/src/cmp/elixir/fragment/Entity.fragment.ex

@@ -0,0 +1,37 @@
+# ProjectName SDK EntityName entity
+#
+# Per-entity module. Generic construction/data/match operations delegate to
+# EntityBase; each active op (load/list/create/update/remove) builds a ctx
+# and drives it through ProjectName.Pipeline.run_op.
+
+defmodule ProjectName.Entity.EntityName do
+  alias Voxgig.Struct, as: S
+  alias ProjectName.Helpers, as: H
+  alias ProjectName.{EntityBase, Context, Pipeline}
+
+  def new(client, entopts \\ nil) do
+    EntityBase.construct(__MODULE__, client, "entityname", entopts)
+  end
+
+  def get_name(ent), do: EntityBase.get_name(ent)
+  def make(ent), do: EntityBase.make(ent)
+  def data_set(ent, args \\ nil), do: EntityBase.data_set(ent, args)
+  def data_get(ent), do: EntityBase.data_get(ent)
+  def match_set(ent, args \\ nil), do: EntityBase.match_set(ent, args)
+  def match_get(ent), do: EntityBase.match_get(ent)
+
+  # Streaming operation (see EntityBase.stream): runs `action` through the
+  # pipeline and returns a lazy Stream over result items.
+  def stream(ent, action, args \\ nil, callopts \\ nil),
+    do: EntityBase.stream(ent, action, args, callopts)
+
+  # #LoadOp
+
+  # #ListOp
+
+  # #CreateOp
+
+  # #UpdateOp
+
+  # #RemoveOp
+end

package/project/.sdk/src/cmp/elixir/fragment/EntityCreateOp.fragment.ex

@@ -0,0 +1,28 @@
+# EJECT-START
+
+  def create(ent, reqdata, ctrl \\ nil) do
+    ctx =
+      Context.new(
+        S.jm([
+          "opname", "create",
+          "ctrl", ctrl,
+          "match", S.getprop(ent, "_match"),
+          "data", S.getprop(ent, "_data"),
+          "reqdata", reqdata
+        ]),
+        S.getprop(ent, "_entctx")
+      )
+
+    post_done = fn ->
+      result = S.getprop(ctx, "result")
+
+      if result != nil do
+        rd = S.getprop(result, "resdata")
+        if rd != nil, do: S.setprop(ent, "_data", H.or_(H.to_map(S.clone(rd)), S.jm([])))
+      end
+    end
+
+    Pipeline.run_op(ctx, post_done)
+  end
+
+# EJECT-END

package/project/.sdk/src/cmp/elixir/fragment/EntityListOp.fragment.ex

@@ -0,0 +1,30 @@
+# EJECT-START
+
+  def list(ent, reqmatch \\ nil, ctrl \\ nil) do
+    reqmatch = if reqmatch == nil, do: S.jm([]), else: reqmatch
+
+    ctx =
+      Context.new(
+        S.jm([
+          "opname", "list",
+          "ctrl", ctrl,
+          "match", S.getprop(ent, "_match"),
+          "data", S.getprop(ent, "_data"),
+          "reqmatch", reqmatch
+        ]),
+        S.getprop(ent, "_entctx")
+      )
+
+    post_done = fn ->
+      result = S.getprop(ctx, "result")
+
+      if result != nil do
+        rm = S.getprop(result, "resmatch")
+        if rm != nil, do: S.setprop(ent, "_match", rm)
+      end
+    end
+
+    Pipeline.run_op(ctx, post_done)
+  end
+
+# EJECT-END

package/project/.sdk/src/cmp/elixir/fragment/EntityLoadOp.fragment.ex

@@ -0,0 +1,32 @@
+# EJECT-START
+
+  def load(ent, reqmatch \\ nil, ctrl \\ nil) do
+    reqmatch = if reqmatch == nil, do: S.jm([]), else: reqmatch
+
+    ctx =
+      Context.new(
+        S.jm([
+          "opname", "load",
+          "ctrl", ctrl,
+          "match", S.getprop(ent, "_match"),
+          "data", S.getprop(ent, "_data"),
+          "reqmatch", reqmatch
+        ]),
+        S.getprop(ent, "_entctx")
+      )
+
+    post_done = fn ->
+      result = S.getprop(ctx, "result")
+
+      if result != nil do
+        rm = S.getprop(result, "resmatch")
+        if rm != nil, do: S.setprop(ent, "_match", rm)
+        rd = S.getprop(result, "resdata")
+        if rd != nil, do: S.setprop(ent, "_data", H.or_(H.to_map(S.clone(rd)), S.jm([])))
+      end
+    end
+
+    Pipeline.run_op(ctx, post_done)
+  end
+
+# EJECT-END