@voxgig/sdkgen 0.35.1 → 0.36.0

package/project/.sdk/src/cmp/lua/fragment/EntityListOp.fragment.lua

@@ -0,0 +1,24 @@
+local entityListOp = {}
+
+-- EJECT-START
+
+function EntityNameEntity:list(reqmatch, ctrl)
+  local utility = self._utility
+  local ctx = utility.make_context({
+    opname = "list",
+    ctrl = ctrl,
+    match = self._match,
+    data = self._data,
+    reqmatch = reqmatch,
+  }, self._entctx)
+
+  return self:_run_op(ctx, function()
+    if ctx.result ~= nil then
+      if ctx.result.resmatch ~= nil then
+        self._match = ctx.result.resmatch
+      end
+    end
+  end)
+end
+
+-- EJECT-END

package/project/.sdk/src/cmp/lua/fragment/EntityLoadOp.fragment.lua

@@ -0,0 +1,30 @@
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local entityLoadOp = {}
+
+-- EJECT-START
+
+function EntityNameEntity:load(reqmatch, ctrl)
+  local utility = self._utility
+  local ctx = utility.make_context({
+    opname = "load",
+    ctrl = ctrl,
+    match = self._match,
+    data = self._data,
+    reqmatch = reqmatch,
+  }, self._entctx)
+
+  return self:_run_op(ctx, function()
+    if ctx.result ~= nil then
+      if ctx.result.resmatch ~= nil then
+        self._match = ctx.result.resmatch
+      end
+      if ctx.result.resdata ~= nil then
+        self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+      end
+    end
+  end)
+end
+
+-- EJECT-END

package/project/.sdk/src/cmp/lua/fragment/EntityRemoveOp.fragment.lua

@@ -0,0 +1,30 @@
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local entityRemoveOp = {}
+
+-- EJECT-START
+
+function EntityNameEntity:remove(reqmatch, ctrl)
+  local utility = self._utility
+  local ctx = utility.make_context({
+    opname = "remove",
+    ctrl = ctrl,
+    match = self._match,
+    data = self._data,
+    reqmatch = reqmatch,
+  }, self._entctx)
+
+  return self:_run_op(ctx, function()
+    if ctx.result ~= nil then
+      if ctx.result.resmatch ~= nil then
+        self._match = ctx.result.resmatch
+      end
+      if ctx.result.resdata ~= nil then
+        self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+      end
+    end
+  end)
+end
+
+-- EJECT-END

package/project/.sdk/src/cmp/lua/fragment/EntityUpdateOp.fragment.lua

@@ -0,0 +1,30 @@
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local entityUpdateOp = {}
+
+-- EJECT-START
+
+function EntityNameEntity:update(reqdata, ctrl)
+  local utility = self._utility
+  local ctx = utility.make_context({
+    opname = "update",
+    ctrl = ctrl,
+    match = self._match,
+    data = self._data,
+    reqdata = reqdata,
+  }, self._entctx)
+
+  return self:_run_op(ctx, function()
+    if ctx.result ~= nil then
+      if ctx.result.resmatch ~= nil then
+        self._match = ctx.result.resmatch
+      end
+      if ctx.result.resdata ~= nil then
+        self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+      end
+    end
+  end)
+end
+
+-- EJECT-END

package/project/.sdk/src/cmp/lua/fragment/Main.fragment.lua

@@ -0,0 +1,256 @@
+-- ProjectName SDK
+
+local vs = require("utility.struct.struct")
+local Utility = require("core.utility_type")
+local Spec = require("core.spec")
+local helpers = require("core.helpers")
+
+-- Load utility registration (populates Utility._registrar)
+require("utility.register")
+
+-- Load features
+local BaseFeature = require("feature.base_feature")
+local features_factory = require("features")
+
+
+local ProjectNameSDK = {}
+ProjectNameSDK.__index = ProjectNameSDK
+
+
+local function _make_feature(name)
+  local factory = features_factory[name]
+  if factory ~= nil then
+    return factory()
+  end
+  return features_factory.base()
+end
+
+ProjectNameSDK._make_feature = _make_feature
+
+
+function ProjectNameSDK.new(options)
+  local self = setmetatable({}, ProjectNameSDK)
+  self.mode = "live"
+  self.features = {}
+  self.options = nil
+
+  local utility = Utility.new()
+  self._utility = utility
+
+  local config = require("config")()
+
+  self._rootctx = utility.make_context({
+    client = self,
+    utility = utility,
+    config = config,
+    options = options or {},
+    shared = {},
+  }, nil)
+
+  self.options = utility.make_options(self._rootctx)
+
+  if vs.getpath(self.options, "feature.test.active") == true then
+    self.mode = "test"
+  end
+
+  self._rootctx.options = self.options
+
+  -- Add features from config.
+  local feature_opts = helpers.to_map(vs.getprop(self.options, "feature"))
+  if feature_opts ~= nil then
+    local feature_items = vs.items(feature_opts)
+    if feature_items ~= nil then
+      for _, item in ipairs(feature_items) do
+        local fname = item[1]
+        local fopts = helpers.to_map(item[2])
+        if fopts ~= nil and fopts["active"] == true then
+          utility.feature_add(self._rootctx, _make_feature(fname))
+        end
+      end
+    end
+  end
+
+  -- Add extension features.
+  local extend = vs.getprop(self.options, "extend")
+  if type(extend) == "table" then
+    for _, f in ipairs(extend) do
+      if type(f) == "table" and type(f.get_name) == "function" then
+        utility.feature_add(self._rootctx, f)
+      end
+    end
+  end
+
+  -- Initialize features.
+  for _, f in ipairs(self.features) do
+    utility.feature_init(self._rootctx, f)
+  end
+
+  utility.feature_hook(self._rootctx, "PostConstruct")
+
+  -- #BuildFeatures
+
+  return self
+end
+
+
+function ProjectNameSDK:options_map()
+  local out = vs.clone(self.options)
+  if type(out) == "table" then
+    return out
+  end
+  return {}
+end
+
+
+function ProjectNameSDK:get_utility()
+  return Utility.copy(self._utility)
+end
+
+
+function ProjectNameSDK:get_root_ctx()
+  return self._rootctx
+end
+
+
+function ProjectNameSDK:prepare(fetchargs)
+  local utility = self._utility
+
+  fetchargs = fetchargs or {}
+
+  local ctrl = helpers.to_map(vs.getprop(fetchargs, "ctrl")) or {}
+
+  local ctx = utility.make_context({
+    opname = "prepare",
+    ctrl = ctrl,
+  }, self._rootctx)
+
+  local options = self.options
+
+  local path = vs.getprop(fetchargs, "path") or ""
+  if type(path) ~= "string" then path = "" end
+
+  local method = vs.getprop(fetchargs, "method") or "GET"
+  if type(method) ~= "string" then method = "GET" end
+
+  local params = helpers.to_map(vs.getprop(fetchargs, "params")) or {}
+  local query = helpers.to_map(vs.getprop(fetchargs, "query")) or {}
+
+  local headers = utility.prepare_headers(ctx)
+
+  local base = vs.getprop(options, "base") or ""
+  if type(base) ~= "string" then base = "" end
+  local prefix = vs.getprop(options, "prefix") or ""
+  if type(prefix) ~= "string" then prefix = "" end
+  local suffix = vs.getprop(options, "suffix") or ""
+  if type(suffix) ~= "string" then suffix = "" end
+
+  ctx.spec = Spec.new({
+    base = base,
+    prefix = prefix,
+    suffix = suffix,
+    path = path,
+    method = method,
+    params = params,
+    query = query,
+    headers = headers,
+    body = vs.getprop(fetchargs, "body"),
+    step = "start",
+  })
+
+  -- Merge user-provided headers.
+  local uh = vs.getprop(fetchargs, "headers")
+  if type(uh) == "table" then
+    for k, v in pairs(uh) do
+      ctx.spec.headers[k] = v
+    end
+  end
+
+  local _, err = utility.prepare_auth(ctx)
+  if err ~= nil then
+    return nil, err
+  end
+
+  return utility.make_fetch_def(ctx)
+end
+
+
+function ProjectNameSDK:direct(fetchargs)
+  local utility = self._utility
+
+  local fetchdef, err = self:prepare(fetchargs)
+  if err ~= nil then
+    return { ok = false, err = err }, nil
+  end
+
+  fetchargs = fetchargs or {}
+  local ctrl = helpers.to_map(vs.getprop(fetchargs, "ctrl")) or {}
+
+  local ctx = utility.make_context({
+    opname = "direct",
+    ctrl = ctrl,
+  }, self._rootctx)
+
+  local url = fetchdef["url"] or ""
+  local fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
+
+  if fetch_err ~= nil then
+    return { ok = false, err = fetch_err }, nil
+  end
+
+  if fetched == nil then
+    return {
+      ok = false,
+      err = ctx:make_error("direct_no_response", "response: undefined"),
+    }, nil
+  end
+
+  if type(fetched) == "table" then
+    local status = helpers.to_int(vs.getprop(fetched, "status"))
+    local json_data = nil
+    local jf = vs.getprop(fetched, "json")
+    if type(jf) == "function" then
+      json_data = jf()
+    end
+
+    return {
+      ok = status >= 200 and status < 300,
+      status = status,
+      headers = vs.getprop(fetched, "headers"),
+      data = json_data,
+    }, nil
+  end
+
+  return {
+    ok = false,
+    err = ctx:make_error("direct_invalid", "invalid response type"),
+  }, nil
+end
+
+
+-- <[SLOT]>
+
+
+function ProjectNameSDK.test(testopts, sdkopts)
+  sdkopts = sdkopts or {}
+  sdkopts = vs.clone(sdkopts)
+  if type(sdkopts) ~= "table" then
+    sdkopts = {}
+  end
+
+  testopts = testopts or {}
+  testopts = vs.clone(testopts)
+  if type(testopts) ~= "table" then
+    testopts = {}
+  end
+  testopts["active"] = true
+
+  vs.setpath(sdkopts, "feature.test", testopts)
+
+  local sdk = ProjectNameSDK.new(sdkopts)
+  sdk.mode = "test"
+
+  return sdk
+end
+
+
+return ProjectNameSDK

package/project/.sdk/src/cmp/lua/fragment/SdkError.fragment.lua

@@ -0,0 +1,26 @@
+-- ProjectName SDK error
+
+local ProjectNameError = {}
+ProjectNameError.__index = ProjectNameError
+
+
+function ProjectNameError.new(code, msg)
+  local self = setmetatable({}, ProjectNameError)
+  self.code = code or ""
+  self.msg = msg or ""
+  self.sdk = "ProjectName"
+  return self
+end
+
+
+function ProjectNameError:error()
+  return self.sdk .. ": " .. self.code .. ": " .. self.msg
+end
+
+
+function ProjectNameError:__tostring()
+  return self:error()
+end
+
+
+return ProjectNameError

package/project/.sdk/src/cmp/lua/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/lua/utility_lua.ts

@@ -0,0 +1,84 @@
+
+import * as Path from 'node:path'
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+function projectPath(suffix?: string): string {
+  return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
+}
+
+
+function formatLuaTable(obj: any, indent: number = 0): string {
+  if (obj == null) {
+    return 'nil'
+  }
+
+  const pad = '  '.repeat(indent)
+  const padInner = '  '.repeat(indent + 1)
+
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return '{}'
+    }
+    const items = obj.map(v => padInner + formatLuaValue(v, indent + 1)).join(',\n')
+    return `{\n${items},\n${pad}}`
+  }
+
+  if (typeof obj === 'object') {
+    const entries = Object.entries(obj)
+    if (entries.length === 0) {
+      return '{}'
+    }
+    const items = entries
+      .map(([k, v]) => `${padInner}["${k}"] = ${formatLuaValue(v, indent + 1)}`)
+      .join(',\n')
+    return `{\n${items},\n${pad}}`
+  }
+
+  return formatLuaValue(obj, indent)
+}
+
+
+function formatLuaValue(val: any, indent: number = 0): string {
+  if (val === null || val === undefined) {
+    return 'nil'
+  }
+  if (typeof val === 'string') {
+    return `"${val.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+  }
+  if (typeof val === 'number') {
+    return String(val)
+  }
+  if (typeof val === 'boolean') {
+    return val ? 'true' : 'false'
+  }
+  if (Array.isArray(val)) {
+    return formatLuaTable(val, indent)
+  }
+  if (typeof val === 'object') {
+    return formatLuaTable(val, indent)
+  }
+  return String(val)
+}
+
+
+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,
+  formatLuaTable,
+  formatLuaValue,
+  projectPath,
+}

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

@@ -0,0 +1,107 @@
+
+import * as Path from 'node:path'
+
+
+import {
+  Content,
+  File,
+  Fragment,
+  Line,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+import {
+  clean,
+  formatPhpArray,
+} from './utility_php'
+
+
+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 authPrefix = getModelPath(model, `main.${KIT}.config.auth.prefix`)
+  const baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
+
+  File({ name: 'config.' + target.ext }, () => {
+
+    Content(`<?php
+declare(strict_types=1);
+
+// ${model.const.Name} SDK configuration
+
+class ${model.const.Name}Config
+{
+    public static function make_config(): array
+    {
+        return [
+            "main" => [
+                "name" => "${model.const.Name}",
+            ],
+            "feature" => [
+`)
+
+    each(feature, (f: any) => {
+      const fconfig = f.config || {}
+      Content(`                "${f.name}" => ${formatPhpArray(fconfig, 4)},
+`)
+    })
+
+    Content(`            ],
+            "options" => [
+                "base" => "${baseUrl}",
+                "auth" => [
+                    "prefix" => "${authPrefix}",
+                ],
+                "headers" => ${formatPhpArray(headers, 4)},
+                "entity" => [
+`)
+
+    each(entity, (entity: any) => {
+      Content(`                    "${entity.name}" => [],
+`)
+    })
+
+    Content(`                ],
+            ],
+            "entity" => ${formatPhpArray(
+      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), {}), 3)},
+        ];
+    }
+
+
+    public static function make_feature(string $name)
+    {
+        require_once __DIR__ . '/features.php';
+        return ${model.const.Name}Features::make_feature($name);
+    }
+}
+`)
+  })
+})
+
+
+export {
+  Config
+}

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

@@ -0,0 +1,44 @@
+
+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
+    }
+  }
+
+  const entop = entity.op[opname]
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.php',
+    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 }, `
+($u->feature_hook)($ctx, "${name}");
+`)
+
+    }
+  })
+})
+
+
+export {
+  EntityOperation
+}

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

@@ -0,0 +1,62 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, camelify, names,
+  File, Content, Folder, Fragment, Line, FeatureHook, Slot
+} from '@voxgig/sdkgen'
+
+import { EntityOperation } from './EntityOperation_php'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target, entity } = props
+
+  const entrep = {
+    ...stdrep,
+  }
+
+  names(entrep, entity.Name, 'EntityName')
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/php/fragment/')
+
+  // Entity files go to entity/ folder
+  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) ? '' : ({ indent }: any) => {
+              EntityOperation({ ff, opname, indent, entity, entrep })
+            }, a), {}))
+
+      Fragment({
+        from: ff + 'Entity.fragment.php',
+        replace: {
+          ...entrep,
+          ProjectName: model.const.Name,
+          EntityName: entity.Name,
+          entityname: entity.name,
+
+          '#Entity-Hook': ({ name, indent }: any) =>
+            Content({ indent }, `($utility->feature_hook)($ctx, "${name}");`),
+
+          ...opfrags,
+        }
+      })
+
+    })
+  })
+})
+
+
+
+export {
+  Entity
+}