@voxgig/sdkgen 0.15.0 → 0.17.0

package/project/generate/tm/js/src/utility/EscurlUtility.js

@@ -0,0 +1,8 @@
+
+function escurl(s) {
+  return encodeURIComponent(s)
+}
+
+module.exports = {
+  escurl
+}

package/project/generate/tm/js/src/utility/FetchUtility.js

@@ -0,0 +1,33 @@
+
+const { fullurl }  = require('./FullurlUtility')
+
+// Make HTTP request.
+async function fetch(ctx) {
+  const {op, spec} = ctx
+  let response = {}
+  
+  try {
+    const url = spec.url = fullurl(ctx)
+    
+    const fetchReq = {
+      method: spec.method,
+      headers: spec.headers,
+    }
+
+    if(null != spec.body) {
+      fetchReq.body =
+        'object' === typeof spec.body ? JSON.stringify(spec.body) : spec.body
+    }
+
+    response = global.fetch(url, fetchReq)
+  }
+  catch(err) {
+    response.err = err
+  }
+  
+  return response
+}
+
+module.exports = {
+  fetch
+}

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

@@ -0,0 +1,41 @@
+
+const { joinurl }  = require('./JoinurlUtility')
+const { escurl }  = require('./EscurlUtility')
+const { escre }  = require('./EscreUtility')
+
+
+function fullurl(ctx) {
+  const { op, spec } = ctx
+  const { query, data } = op
+  
+  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] = 'res' === op.kind ? query[key] : data[key]
+    }
+  }
+  
+  for(let key in params) {
+    const val = spec.params[key]
+    if(null != val) { 
+      url = url.replace(RegExp('{'+escre(key)+'}'), escurl(val))
+    }
+  }
+
+  let qsep = '?'
+  for(let key in spec.query) {
+    const val = spec.query[key]
+    if(null != val) { 
+      url += qsep + escurl(key) + '=' + escurl(val)
+      qsep = '&'
+    }
+  }
+  
+  return url
+}
+
+module.exports = {
+  fullurl
+}

package/project/generate/tm/js/src/utility/HeadersUtility.js

@@ -0,0 +1,12 @@
+
+function headers(ctx) {
+  const out = {}
+
+  out['content-type'] =  'application/json'
+  
+  return out
+}
+
+module.exports = {
+  headers
+}

package/project/generate/tm/js/src/utility/InwardUtility.js

@@ -0,0 +1,23 @@
+
+const { error } = require('./ErrorUtility')
+
+function inward(ctx) {
+  if (!ctx.result.ok) {
+    return undefined
+  }
+
+  try {
+    return ctx.op.inward(ctx)
+  }
+  catch (err) {
+    // TDOD: need error codes and err msg text
+    ctx.result.ok = false
+    ctx.result.err = err
+    return error(ctx)
+  }
+}
+
+
+module.exports = {
+  inward
+}

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

@@ -0,0 +1,12 @@
+
+function joinurl(...s) {
+  return s
+    .filter(s=>null!=s&&''!==s)
+    .map(s=>s.replace(/^\/+/,'').replace(/\/+$/,''))
+    .filter(s=>null!=s&&''!==s)
+    .join('/')
+}
+
+module.exports = {
+  joinurl
+}

package/project/generate/tm/js/src/utility/MethodUtility.js

@@ -0,0 +1,21 @@
+
+function method(ctx) {
+  const { op } = ctx
+  const opname = op.name
+  
+  let key = opname
+
+  const mmap = {
+    create: 'POST',
+    save: 'PUT',
+    load: 'GET',
+    list: 'GET',
+    remove: 'DELETE',
+  }
+
+  return mmap[key]
+}
+
+module.exports = {
+  method
+}

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

@@ -0,0 +1,36 @@
+
+
+// NOTE: duplicated in @voxgig/apidef - dedup to @voxgig/util?
+const OPKIND = {
+  create: 'req',
+  update: 'req',
+  remove: 'req',
+  load: 'res',
+  list: 'res',
+}
+
+
+// Ensure standard operation definition.
+function operator(ctx) {
+  const { op } = ctx
+  
+  let out = {
+    name: op.name,
+    kind: OPKIND[op.name],
+    entity: op.entity,
+    path: op.path,
+    params: op.params || [],
+    query: {...op.query} || {},
+    data: {...op.data} || {},
+    state: op.state,
+    inward: op.inward,
+    outward: op.outward,
+  }
+
+  return out
+}
+
+
+module.exports = {
+  operator
+}

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

@@ -0,0 +1,22 @@
+
+const { empty }  = require('./EmptyUtility')
+
+function options(ctx) {
+  let config = ctx.config || {}
+  let copts = config.options || {}
+  
+  let options = { ...(ctx.options||{}) }
+
+  options.base = empty(options.base) ?
+    empty(copts.base) ? 'http://localhost:8000' :
+    copts.base : options.base
+
+  options.prefix = empty(options.prefix) ? '' : options.prefix
+  options.suffix = empty(options.suffix) ? '' : options.suffix
+  
+  return options
+}
+
+module.exports = {
+  options
+}

package/project/generate/tm/js/src/utility/OutwardUtility.js

@@ -0,0 +1,23 @@
+
+const { error } = require('./ErrorUtility')
+
+function outward(ctx) {
+  if (!ctx.result.ok) {
+    return undefined
+  }
+
+  try {
+    return ctx.op.outward(ctx)
+  }
+  catch (err) {
+    // TDOD: need error codes and err msg text
+    ctx.result.ok = false
+    ctx.result.err = err
+    return error(ctx)
+  }
+}
+
+
+module.exports = {
+  outward
+}

package/project/generate/tm/js/src/utility/ParamsUtility.js

@@ -0,0 +1,20 @@
+
+function params(ctx) {
+  const { op } = ctx
+
+  const { params, query } = op
+
+  const out = {}
+  for(let key of params) {
+    let val = query[key]
+    if(null!=val) {
+      out[key] = val
+    }
+  }
+
+  return out
+}
+
+module.exports = {
+  params
+}

package/project/generate/tm/js/src/utility/QueryUtility.js

@@ -0,0 +1,19 @@
+
+function query(ctx) {
+  const { op } = ctx
+  const { params, query } = op
+
+  const out = {}
+  for(let key of Object.keys(query)) {
+    let val = query[key]
+    if(null!=val && !params.includes(key)) {
+      out[key] = val
+    }
+  }
+
+  return out
+}
+
+module.exports = {
+  query
+}

package/project/generate/tm/js/src/utility/ResbasicUtility.js

@@ -0,0 +1,17 @@
+
+function resbasic(response, fetchResponse) {
+  response.status = fetchResponse.status
+  response.statusText = fetchResponse.statusText || 'no-status'
+
+  // TODO: use spec!
+  if(400 <= response.status) {
+    response.ok = false
+    response.err = new Error(response.status+': '+response.statusText)
+  }
+  
+  return response
+}
+
+module.exports = {
+  resbasic
+}

package/project/generate/tm/js/src/utility/ResbodyUtility.js

@@ -0,0 +1,10 @@
+
+async function resbody(response, fetchResponse) {
+  const json = await fetchResponse.json()
+  response.body = json
+  return response
+}
+
+module.exports = {
+  resbody
+}

package/project/generate/tm/js/src/utility/ResheadersUtility.js

@@ -0,0 +1,11 @@
+
+function resheaders(response, fetchResponse) {
+  out = {}
+  fetchResponse.headers.forEach((v,k)=>out[k]=v)
+  response.headers = out
+  return response
+}
+
+module.exports = {
+  resheaders
+}

package/project/generate/tm/js/src/utility/ResponseUtility.js

@@ -0,0 +1,36 @@
+
+const { resheaders }  = require('./ResheadersUtility')
+const { resbasic }  = require('./ResbasicUtility')
+const { resbody }  = require('./ResbodyUtility')
+
+async function response(ctx) {
+  let { response } = ctx
+  
+  let result = {
+    ok: false,
+    status: -1,
+    statusText: '',
+    headers: {},
+    body: undefined,
+    err: response.err,
+  }
+
+  try {
+    result = resbasic(result, response)
+    result = resheaders(result, response)
+    result = await resbody(result, response)
+    
+    if(null == result.err) {
+      result.ok = true
+    }
+  }
+  catch(err) {
+    result.err = err
+  }
+  
+  return result
+}
+
+module.exports = {
+  response
+}

package/project/generate/tm/js/src/utility/SpecUtility.js

@@ -0,0 +1,41 @@
+
+const { method }  = require('./MethodUtility')
+const { params }  = require('./ParamsUtility')
+const { query }  = require('./QueryUtility')
+const { headers }  = require('./HeadersUtility')
+const { body }  = require('./BodyUtility')
+const { auth }  = require('./AuthUtility')
+
+// Create request specificaton.
+function spec(ctx) {
+  const {client, op} = ctx
+  
+  let options = client.options()
+
+  const reqMethod = method(ctx)
+  const reqParams = params(ctx)
+  const reqQuery = query(ctx)
+  const reqHeaders = headers(ctx)
+  const reqBody = body(ctx)
+
+  let spec = {
+    base: options.base, // string, URL endpoint base prefix,
+    prefix: options.prefix,
+    path: op.path,
+    suffix: options.suffix,
+    method: reqMethod,
+    params: reqParams,
+    query: reqQuery,
+    headers: reqHeaders,
+    body: reqBody,
+  }
+
+  spec = auth(ctx, spec)
+  
+  return spec
+}
+
+
+module.exports = {
+  spec
+}

package/project/generate/tm/js/src/utility/Utility.js

@@ -0,0 +1,55 @@
+
+const { auth } = require('./AuthUtility')
+const { body } = require('./BodyUtility')
+const { empty } = require('./EmptyUtility')
+const { error } = require('./ErrorUtility')
+const { escre } = require('./EscreUtility')
+const { escurl } = require('./EscurlUtility')
+const { fetch } = require('./FetchUtility')
+const { fullurl } = require('./FullurlUtility')
+const { headers } = require('./HeadersUtility')
+const { inward } = require('./InwardUtility')
+const { joinurl } = require('./JoinurlUtility')
+const { method } = require('./MethodUtility')
+const { operator } = require('./OperatorUtility')
+const { options } = require('./OptionsUtility')
+const { outward } = require('./outwardUtility')
+const { params } = require('./ParamsUtility')
+const { query } = require('./QueryUtility')
+const { resbasic } = require('./ResbasicUtility')
+const { resbody } = require('./ResbodyUtility')
+const { resheaders } = require('./ResheadersUtility')
+const { response } = require('./ResponseUtility')
+const { spec } = require('./SpecUtility')
+
+
+const Utility = {
+  auth,
+  body,
+  empty,
+  error,
+  escre,
+  escurl,
+  fetch,
+  fullurl,
+  headers,
+  inward,
+  joinurl,
+  method,
+  operator,
+  options,
+  outward,
+  params,
+  query,
+  resbasic,
+  resbody,
+  resheaders,
+  response,
+  spec,
+}
+
+
+module.exports = {
+  Utility
+}
+

package/src/action/feature.ts

@@ -0,0 +1,120 @@
+
+import {
+  Jostraca,
+  Project,
+  File,
+  Folder,
+  Content,
+  Copy,
+  cmp,
+  each,
+} from 'jostraca'
+
+
+import { SdkGenError } from '../utility'
+
+
+const CMD_MAP: any = {
+  add: cmd_feature_add
+}
+
+const BASE = 'node_modules/@voxgig/sdkgen'
+
+async function action_feature(args: any[], ctx: any) {
+
+  const cmdname = args[1]
+
+  const cmd = CMD_MAP[cmdname]
+
+  if (null == cmd) {
+    throw new SdkGenError('Unknown feature cmd: ' + cmdname)
+  }
+
+  await cmd(args, ctx)
+}
+
+
+async function cmd_feature_add(args: any[], ctx: any) {
+
+  let features = args[2]
+  features = 'string' === typeof features ? features.split(',') : features
+
+  const jostraca = Jostraca()
+
+  const opts = {
+    fs: ctx.fs,
+    folder: ctx.folder,
+    log: ctx.log.child({ cmp: 'jostraca' }),
+    meta: { model: ctx.model, tree: ctx.tree }
+  }
+
+  await jostraca.generate(opts, () => FeatureRoot({ features }))
+
+}
+
+
+const FeatureRoot = cmp(function FeatureRoot(props: any) {
+  const { ctx$, features } = props
+
+  // TODO: model should be a top level ctx property
+  const model = ctx$.model = ctx$.meta.model
+  const target = model.main.sdk.target
+
+  Project({}, () => {
+    each(features, (n) => {
+      const name = n.val$
+      // TODO: validate feature is a-z0-9-_. only
+
+      Folder({ name: 'model/feature' }, () => {
+        Copy({
+          from: BASE + '/project/generate/model/feature/' + name + '.jsonic',
+          exclude: true
+        })
+      })
+
+      each(target, (target) =>
+        Folder({ name: 'tm/' + target.name + '/src/feature/' + name }, () => {
+          Copy({
+            from: BASE + '/project/generate/tm/' + target.name + '/src/feature/' + name,
+            exclude: true
+          })
+        }))
+
+    })
+  })
+
+  modifyModel({
+    features,
+    model: ctx$.meta.model,
+    tree: ctx$.meta.tree,
+    fs: ctx$.fs
+  })
+
+})
+
+
+async function modifyModel({ features, model, tree, fs }: any) {
+  // TODO: This is a kludge.
+  // Aontu should provide option for as-is AST so that can be used
+  // to find injection point more reliably
+
+  const path = tree.url
+  let src = fs().readFileSync(path, 'utf8')
+
+  // Inject feature file references into model
+  features.sort().map((feature: string) => {
+    const lineRE =
+      new RegExp(`@"feature/${feature}.jsonic"`)
+    if (!src.match(lineRE)) {
+      src = src.replace(/(main:\s+sdk:\s+feature:\s+\{\s*\}\n)/, '$1' +
+        `@"feature/${feature}.jsonic"\n`)
+    }
+  })
+
+  fs().writeFileSync(path, src)
+}
+
+
+export {
+  action_feature
+}