@voxgig/sdkgen 0.17.0 → 0.18.0

package/project/.sdk/src/cmp/ts/fragment/EntityLoadOp.fragment.js

@@ -0,0 +1,61 @@
+class EntityOperation { // REMOVED
+
+async load(match) {
+  const entity = this
+  const client = this.#client
+  const utility = this.#utility
+  const { operator, spec, request, response, result, error, struct, done } = utility
+  
+  const op = {
+    entity: 'Name',
+    name: 'load',
+    path: 'PATH',
+    params: ['PARAM-LIST'],
+    alias: {'ALIAS':'MAP'},
+    match,
+    data: this.#data,
+    state: {},
+    reqform: 'REQFORM',
+    resform: 'RESFORM',
+  }
+
+  let ctx = { client, entity, op, utility}
+
+  
+  // #PreOperation-Hook    
+
+  await operator(ctx)
+
+  
+  // #PreSpec-Hook
+
+  this.#match = op.match
+  
+  await spec(ctx)
+
+  
+  // #PreRequest-Hook
+
+  await request(ctx)
+
+  
+  // #PreResponse-Hook
+
+  await response(ctx)
+
+  
+  // #PreResult-Hook
+  
+  await result(ctx)
+
+  
+  // #PostOperation-Hook
+
+  if(null != ctx.result.resdata) {
+    this.#data = ctx.result.resdata
+  }
+
+  return done(ctx)
+}
+
+} // REMOVED

package/project/.sdk/src/cmp/ts/fragment/EntityRemoveOp.fragment.js

@@ -0,0 +1,61 @@
+class EntityOperation { // REMOVED
+
+async remove(match) {
+  let entity = this
+  let client = this.#client
+  const utility = this.#utility
+  const { operator, spec, request, response, result, error, struct, done } = utility
+  
+  let op = {
+    entity: 'Name',
+    name: 'remove',
+    path: 'PATH',
+    params: ['PARAM-LIST'],
+    alias: {'ALIAS':'MAP'},
+    match,
+    data: this.#data,
+    state: {},
+    reqform: 'REQFORM',
+    resform: 'RESFORM',
+  }
+
+  let ctx = {client, entity, op, utility}
+
+
+  // #PreOperation-Hook    
+
+  await operator(ctx)
+
+  
+  // #PreSpec-Hook
+
+  this.#data = op.data
+  
+  await spec(ctx)
+
+  
+  // #PreRequest-Hook
+
+  await request(ctx)
+
+  
+  // #PreResponse-Hook
+
+  await response(ctx)
+
+  
+  // #PreResult-Hook
+
+  await result(ctx)
+
+
+  // #PostOperation-Hook
+
+  if(null != ctx.result.resdata) {
+    this.#data = ctx.result.resdata
+  }
+
+  return done(ctx)
+}
+  
+} // REMOVED

package/project/.sdk/src/cmp/ts/fragment/EntityUpdateOp.fragment.js

@@ -0,0 +1,61 @@
+class EntityOperation { // REMOVED
+
+async update(data) {
+  let entity = this
+  let client = this.#client
+  const utility = this.#utility
+  const { operator, spec, request, response, result, error, struct, done } = utility
+  
+  let op = {
+    entity: 'Name',
+    name: 'update',
+    path: 'PATH',
+    params: ['PARAM-LIST'],
+    alias: {'ALIAS':'MAP'},
+    match: this.#match,
+    data: null == data ? this.#data : data,
+    state: {},
+    reqform: 'REQFORM',
+    resform: 'RESFORM',
+  }
+  
+  let ctx = {client, entity, op, utility}
+
+
+  // #PreOperation-Hook    
+
+  await operator(ctx)
+
+  
+  // #PreSpec-Hook
+
+  this.#data = op.data
+  
+  await spec(ctx)
+
+  
+  // #PreRequest-Hook
+
+  await request(ctx)
+
+  
+  // #PreResponse-Hook
+
+  await response(ctx)
+
+  
+  // #PreResult-Hook
+
+  await result(ctx)
+
+
+  // #PostOperation-Hook
+
+  if(null != ctx.result.resdata) {
+    this.#data = ctx.result.resdata
+  }
+
+  return done(ctx)
+}
+
+} // REMOVED

package/project/.sdk/src/cmp/ts/fragment/Main.fragment.js

@@ -0,0 +1,67 @@
+
+const { Config } = require('./Config')
+const { Utility } = require('./utility/Utility')
+
+
+class NameSDK {
+  #options
+  #features
+  #utility = Utility
+  
+  constructor(options) {
+
+    this.#options = this.#utility.options({
+      client: this,
+      utility: this.#utility,
+      config: Config,
+      options,
+    })
+
+    // #FeatureOptions
+
+    this.#features = {
+      // #BuildFeature
+    }
+
+    // #PostConstruct-Hook
+  }
+
+
+  options() {
+    return { ...this.#options }
+  }
+
+  features() {
+    return { ...this.#features }
+  }
+
+  utility() {
+    return { ...this.#utility }
+  }
+
+
+  static test(opts) {
+    return new NameSDK({
+      // #TestOptions
+      ...(opts || {})
+    })
+  }
+
+  test(opts) {
+    return new NameSDK({
+      // #TestOptions
+      ...(opts || this.#options || {})
+    })
+  }
+
+  
+  // <[SLOT]>
+}
+
+
+const SDK = NameSDK
+
+module.exports = {
+  NameSDK,
+  SDK,
+}

package/project/{generate → .sdk}/tm/js/src/feature/log/LogFeature.js

@@ -52,6 +52,10 @@ class LogFeature {
     this.#loghook('PostConstruct', ctx)
   }
 
+  PostConstructEntity(ctx) {
+    this.#loghook('PostConstructEntity', ctx)
+  }
+
   SetData(ctx) {
     this.#loghook('SetData', ctx)
   }
@@ -60,8 +64,8 @@ class LogFeature {
     this.#loghook('GetData', ctx)
   }
   
-  GetQuery(ctx) {
-    this.#loghook('GetQuery', ctx)
+  GetMatch(ctx) {
+    this.#loghook('GetMatch', ctx)
   }
 
 
@@ -69,20 +73,20 @@ class LogFeature {
     this.#loghook('PreOperation', ctx)
   }
 
-  ModifyOp(ctx) {
-    this.#loghook('ModifyOp', ctx)
+  PreSpec(ctx) {
+    this.#loghook('PreSpec', ctx)
   }
 
-  PreFetch(ctx) {
-    this.#loghook('PreFetch', ctx)
+  PreRequest(ctx) {
+    this.#loghook('PreRequest', ctx)
   }
 
-  PostFetch(ctx) {
-    this.#loghook('PostFetch', ctx)
+  PreResponse(ctx) {
+    this.#loghook('PreResponse', ctx)
   }
 
-  ModifyResult(ctx) {
-    this.#loghook('ModifyResult', ctx)
+  PreResult(ctx) {
+    this.#loghook('PreResult', ctx)
   }
  
   PostOperation(ctx) {

package/project/.sdk/tm/js/src/utility/AuthUtility.js

@@ -0,0 +1,21 @@
+
+function auth(ctx) {
+  const { client, spec } = ctx
+  const { headers } = spec
+  
+  let options = client.options()
+
+  if(null != options.apikey && '' !== options.apikey) {
+    headers['authorization'] = 'Bearer '+options.apikey
+  }
+  else {
+    delete headers['authorization']
+  }
+  
+  return spec
+}
+
+
+module.exports = {
+  auth
+}

package/project/.sdk/tm/js/src/utility/BodyUtility.js

@@ -0,0 +1,29 @@
+
+
+function body(ctx) {
+  const { op, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+  
+  let body = undefined
+
+  if('req' === op.kind) {
+    try {
+      const reqform = op.reqform
+      body = isfunc(reqform) ? reqform(ctx) : transform(op, op.reqform)
+
+      if(op.check.nobody && null == body) {
+        return error(ctx, new Error('Request body is empty.'))
+      }
+    }
+    catch (err) {
+      return error(ctx, err)
+    }
+  }
+
+  return body
+}
+
+module.exports = {
+  body
+}

package/project/.sdk/tm/js/src/utility/DoneUtility.js

@@ -0,0 +1,15 @@
+
+function done(ctx) {
+  const { error } = ctx.utility
+  
+  if(ctx.result.ok) {
+    return ctx.result.resdata
+  }
+
+  return error(ctx)
+}
+
+
+module.exports = {
+  done
+}

package/project/.sdk/tm/js/src/utility/ErrorUtility.js

@@ -0,0 +1,33 @@
+
+function error(ctx, err) {
+
+  ctx = ctx || {}
+  const op = ctx.op || {}
+  op.name = op.name || 'unknown operation'
+
+  const result = ctx.result = ctx.result || {}
+  result.ok = false
+  
+  const reserr = result.err
+  
+  err = undefined === err ? reserr : err
+  err = err || new Error('unknown error')
+  
+  const errmsg = err.message || 'unknown error'
+  const msg = 'StatuspageSDK: '+op.name+': '+errmsg
+  err.message = msg
+  // result.err = {...err}
+  
+  const spec = ctx.spec || {}
+
+  err.result = ctx.result
+  err.spec = spec
+
+  // TODO: model option to return instead
+  throw err
+}
+
+
+module.exports = {
+  error
+}

package/project/.sdk/tm/js/src/utility/FindparamUtility.js

@@ -0,0 +1,31 @@
+
+/* Find value of a match parameter, possibly using an alias.
+ *
+ * The match parameter may have an alias key. For example, the parameter `foo_id` may be
+ * aliased to `id` in the entity data.
+ *
+ * This function returns `undefined` rather than failing.
+ */
+function findparam(ctx, key) {
+  let { op, spec } = ctx
+  let { match, data, alias } = op
+
+  let source = ('res' === op.kind ? match : data) || {}
+  let val = source[key]
+
+  if(null == val) {
+    alias = alias || {}
+    let akey = alias[key]
+    val = source[akey]
+
+    spec = spec || {}
+    spec.alias = spec.alias || {}
+    spec.alias[akey] = key
+  }
+
+  return val
+}
+
+module.exports = {
+  findparam
+}

package/project/.sdk/tm/js/src/utility/FullurlUtility.js

@@ -0,0 +1,39 @@
+
+
+function fullurl(ctx) {
+  const { op, spec, utility: { struct, findparam } } = ctx
+  const { escurl, escre, joinurl } = struct
+  
+  let url = joinurl([spec.base, spec.prefix, spec.path, spec.suffix])
+
+  const params = spec.params
+  for(let key of op.params) {
+    if(null == params[key]) {
+      params[key] = findparam(ctx, key)
+    }
+  }
+  
+  for(let key in params) {
+    const val = params[key]
+    if(null != val) { 
+      url = url.replace(RegExp('{'+escre(key)+'}'), escurl(val))
+    }
+  }
+
+  let qsep = '?'
+  for(let key in spec.query) {
+    if(null == spec.alias[key]) {
+      const val = spec.query[key]
+      if(null != val) { 
+        url += qsep + escurl(key) + '=' + escurl(val)
+        qsep = '&'
+      }
+    }
+  }
+
+  return url
+}
+
+module.exports = {
+  fullurl
+}

package/project/{generate → .sdk}/tm/js/src/utility/HeadersUtility.js

@@ -2,7 +2,8 @@
 function headers(ctx) {
   const out = {}
 
-  out['content-type'] =  'application/json'
+  // TODO: should come from options via config
+  out['content-type'] = 'application/json'
   
   return out
 }

package/project/.sdk/tm/js/src/utility/JoinurlUtility.js

@@ -0,0 +1,14 @@
+
+// TODO: MOVE TO STRUCT
+function joinurl(...s) {
+  return s
+    .filter(s=>null!=s&&''!==s)
+    .map((s,i)=> 0===i ? s.replace(/([^\/])\/+/,'$1/').replace(/\/+$/,'') :
+        s.replace(/([^\/])\/+/,'$1/').replace(/^\/+/,'').replace(/\/+$/,''))
+    .filter(s=>''!==s)
+    .join('/')
+}
+
+module.exports = {
+  joinurl
+}

package/project/{generate → .sdk}/tm/js/src/utility/MethodUtility.js

@@ -5,9 +5,10 @@ function method(ctx) {
   
   let key = opname
 
+  // TODO: options
   const mmap = {
     create: 'POST',
-    save: 'PUT',
+    update: 'PUT',
     load: 'GET',
     list: 'GET',
     remove: 'DELETE',

package/project/.sdk/tm/js/src/utility/OperatorUtility.js

@@ -0,0 +1,44 @@
+
+
+const OPKIND = {
+  create: 'req',
+  update: 'req',
+  remove: 'req',
+  load: 'res',
+  list: 'res',
+}
+
+
+// Ensure standard operation definition.
+function operator(ctx) {
+  const { op, utility } = ctx
+  const { validate } = utility.struct
+
+  const opspec = {
+
+    // Required.
+    name: '`$STRING`',
+    kind: ['`$ONE`','req','res'],
+    path: '`$STRING`',
+    entity: '`$STRING`',
+    reqform: ['`$ONE`','`$STRING`','`$OBJECT`','`$FUNCTION`'],
+    resform: ['`$ONE`','`$STRING`','`$OBJECT`','`$FUNCTION`'],
+
+    // Optional.
+    params: ['`$CHILD`', '`$STRING`'],
+    alias: {'`$CHILD`': '`$STRING`' },
+    match: {},
+    data: ['`$ONE`',{}, []],
+    state: {},
+    check: {},
+  }
+
+  ctx.op.kind = OPKIND[op.name]
+  
+  ctx.op = validate(ctx.op, opspec)
+}
+
+
+module.exports = {
+  operator
+}

package/project/.sdk/tm/js/src/utility/OptionsUtility.js

@@ -0,0 +1,54 @@
+
+function options(ctx) {
+  const { options, utility } = ctx
+  
+  let opts = { ...(options||{}) }
+  
+  const customUtils = opts.utility || {}
+  for(let key of Object.keys(customUtils)) {
+    utility[key] = customUtils[key]
+  }
+  
+  const { isempty, merge, validate } = utility.struct
+
+  let config = ctx.config || {}
+  let cfgopts = config.options || {}
+  
+  // Standard SDK option values.
+  const optspec = {
+    apikey: '',
+    base: 'http://localhost:8000',
+    prefix: '',
+    suffix: '',
+    entity: {
+      '`$CHILD`': {
+        '`$OPEN`': true, 
+        active: false,
+        alias: {}
+      }
+    },
+    feature: {
+      '`$CHILD`': {
+        '`$OPEN`': true,
+        active: false, 
+      }
+    },
+    utility: {},
+    system: {},
+  }
+
+  // JavaScript specific option values.
+  optspec.system.fetch = optspec.system.fetch || global.fetch
+
+  opts = merge([{},cfgopts,opts])
+
+  opts = validate(opts, optspec)
+
+  return opts
+}
+
+
+
+module.exports = {
+  options
+}

package/project/{generate → .sdk}/tm/js/src/utility/ParamsUtility.js

@@ -1,12 +1,13 @@
 
 function params(ctx) {
   const { op } = ctx
-
-  const { params, query } = op
-
+  let { params, match } = op
+  params = params || []
+  match = match || {}
+  
   const out = {}
   for(let key of params) {
-    let val = query[key]
+    let val = match[key]
     if(null!=val) {
       out[key] = val
     }

package/project/{generate → .sdk}/tm/js/src/utility/QueryUtility.js

@@ -1,11 +1,13 @@
 
 function query(ctx) {
   const { op } = ctx
-  const { params, query } = op
-
+  let { params, match } = op
+  params = params || []
+  match = match || {}
+  
   const out = {}
-  for(let key of Object.keys(query)) {
-    let val = query[key]
+  for(let key of Object.keys(match)) {
+    let val = match[key]
     if(null!=val && !params.includes(key)) {
       out[key] = val
     }

package/project/.sdk/tm/js/src/utility/ReqformUtility.js

@@ -0,0 +1,32 @@
+
+/* Convert entity data or match query into a srtucture suitable for use as request data.
+ *
+ * The operation (op) property `reqform` is used to perform the data preparation.
+ */
+function reqform(ctx) {
+  const { op, spec, result, utility } = ctx
+  const { struct, error } = utility
+  const { isfunc, transform } = struct
+
+  if(spec) {
+    spec.step = 'reqform'
+  }
+  
+  // if (!result.ok) {
+  //   return undefined
+  // }
+
+  try {
+    const reqform = ctx.op.reqform
+    const reqdata = isfunc(reqform) ? reqform(ctx) : transform(ctx.op, reqform)
+    return reqdata
+  }
+  catch (err) {
+    return error(ctx, err)
+  }
+}
+
+
+module.exports = {
+  reqform
+}