@voxgig/sdkgen 0.22.0 → 0.23.0

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

@@ -0,0 +1,107 @@
+
+import type { Feature } from './types'
+
+import { Config } from './Config'
+import { Utility } from './utility/Utility'
+
+
+import { BaseFeature } from './feature/base/BaseFeature'
+
+const utility = new Utility()
+
+
+class ProjectNameSDK {
+  #options: any
+  #utility = utility
+
+  _features: Feature[]
+
+
+  constructor(options?: any) {
+
+    const ctx = this.#utility.contextify({
+      client: this,
+      utility: this.#utility,
+      config: Config,
+      options,
+    })
+
+    this.#options = this.#utility.options(ctx)
+
+    ctx.options = this.#options
+
+    this._features = []
+
+    const addfeature = this.#utility.addfeature
+    const initfeature = this.#utility.initfeature
+
+    // #BuildFeatures
+
+    if (null != this.#options.extend) {
+      for (let f of this.#options.extend) {
+        addfeature(ctx, f)
+      }
+    }
+
+    for (let f of this._features) {
+      initfeature(ctx, f)
+    }
+
+    const featurehook = this.#utility.featurehook
+    featurehook(ctx, 'PostConstruct')
+  }
+
+
+  options() {
+    return { ...this.#options }
+  }
+
+
+  utility() {
+    return { ...this.#utility }
+  }
+
+
+  // <[SLOT]>
+
+
+  static test(testopts?: any, sdkopts?: any) {
+    const active = null == testopts ? false : null == testopts.active ? true : !!testopts.active
+    testopts = testopts || {}
+    testopts.active = active
+
+    sdkopts = sdkopts || {}
+    sdkopts.feature = sdkopts.feature || {}
+    sdkopts.feature.test = testopts || {}
+    sdkopts.feature.test.active = true
+
+    return new ProjectNameSDK(sdkopts)
+  }
+
+
+  tester(testopts?: any, sdkopts?: any) {
+    return ProjectNameSDK.test(testopts, sdkopts)
+  }
+
+}
+
+
+class ProjectNameEntity {
+
+}
+
+
+
+const SDK = ProjectNameSDK
+
+export {
+  utility,
+
+  BaseFeature,
+  ProjectNameEntity,
+
+  ProjectNameSDK,
+  SDK,
+}
+
+

package/project/.sdk/src/cmp/ts/utility_ts.ts

@@ -0,0 +1,10 @@
+
+function formatJSONSrc(jsonsrc: string) {
+  return jsonsrc
+    .replace(/([{:\[,])/g, '$1 ')
+    .replace(/([}\]])/g, ' $1')
+}
+
+export {
+  formatJSONSrc
+}

package/project/.sdk/tm/ts/src/feature/base/BaseFeature.ts

@@ -0,0 +1,43 @@
+import type { Feature, Context, FeatureOptions } from '../../types'
+
+
+
+
+class BaseFeature implements Feature {
+  version = '0.0.1'
+  name = 'base'
+  active = true
+
+
+  init(_ctx: Context, _options: FeatureOptions): void | Promise<any> { }
+
+
+  PostConstruct(this: any, _ctx: any) { }
+
+  PostConstructEntity(this: any, _ctx: any) { }
+
+  SetData(this: any, _ctx: any) { }
+
+  GetData(this: any, _ctx: any) { }
+
+  GetMatch(this: any, _ctx: any) { }
+
+
+  PreOperation(this: any, _ctx: any) { }
+
+  PreSpec(this: any, _ctx: any) { }
+
+  PreRequest(this: any, _ctx: any) { }
+
+  PreResponse(this: any, _ctx: any) { }
+
+  PreResult(this: any, _ctx: any) { }
+
+  PostOperation(this: any, _ctx: any) { }
+
+}
+
+
+export {
+  BaseFeature
+}

package/project/.sdk/tm/ts/src/feature/log/LogFeature.ts

@@ -0,0 +1,109 @@
+
+import type { Context, FeatureOptions } from '../../types'
+import type { ProjectNameSDK } from '../../ProjectNameSDK'
+
+import { BaseFeature } from '../base/BaseFeature'
+
+
+import Pino from 'pino'
+import PinoPretty from 'pino-pretty'
+
+
+
+class LogFeature extends BaseFeature {
+  version = '0.0.1'
+  name = 'log'
+  active = true
+
+  _client?: ProjectNameSDK
+  _options?: any
+  _logger?: any
+
+
+  init(ctx: Context, options: FeatureOptions): void | Promise<any> {
+    this._client = ctx.client
+    this._options = options as any
+    this.active = options.active
+
+    if (this.active) {
+      let logger = this._options.logger
+
+      if (null == logger) {
+        let pretty = PinoPretty({
+          sync: true,
+          ignore: 'ctx',
+        })
+
+        let level = this._options.level || 'info'
+
+        logger = Pino({ name: 'log', level }, pretty)
+
+        this._logger = logger
+      }
+    }
+  }
+
+
+  PostConstruct(this: any, ctx: any) {
+    this._loghook('PostConstruct', ctx)
+  }
+
+  PostConstructEntity(this: any, ctx: any) {
+    this._loghook('PostConstructEntity', ctx)
+  }
+
+  SetData(this: any, ctx: any) {
+    this._loghook('SetData', ctx)
+  }
+
+  GetData(this: any, ctx: any) {
+    this._loghook('GetData', ctx)
+  }
+
+  GetMatch(this: any, ctx: any) {
+    this._loghook('GetMatch', ctx)
+  }
+
+
+  PreOperation(this: any, ctx: any) {
+    this._loghook('PreOperation', ctx)
+  }
+
+  PreSpec(this: any, ctx: any) {
+    this._loghook('PreSpec', ctx)
+  }
+
+  PreRequest(this: any, ctx: any) {
+    this._loghook('PreRequest', ctx)
+  }
+
+  PreResponse(this: any, ctx: any) {
+    this._loghook('PreResponse', ctx)
+  }
+
+  PreResult(this: any, ctx: any) {
+    this._loghook('PreResult', ctx)
+  }
+
+  PostOperation(this: any, ctx: any) {
+    this._loghook('PostOperation', ctx)
+  }
+
+
+  _loghook(this: any, hook: any, ctx: any, level: any) {
+    level = level || 'info'
+    if (this._logger) {
+      this._logger[level]({
+        hook,
+        op: ctx.op,
+        spec: ctx.spec,
+        ctx
+      })
+    }
+  }
+}
+
+
+export {
+  LogFeature
+}

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -0,0 +1,159 @@
+
+import type { Context, FeatureOptions } from '../../types'
+import type { ProjectNameSDK } from '../../ProjectNameSDK'
+
+import { BaseFeature } from '../base/BaseFeature'
+
+
+class TestFeature extends BaseFeature {
+  version = '0.0.1'
+  name = 'test'
+  active = true
+
+  _client?: ProjectNameSDK
+  _options?: any
+
+
+  init(ctx: Context, options: FeatureOptions): void | Promise<any> {
+    this._client = ctx.client
+    this._options = options
+
+    // console.log('TEST FEATURE', this._options)
+
+    const { struct } = ctx.utility
+    const { walk, size, setprop, stringify } = struct
+
+    const entity = this._options.entity
+
+    // Set entity ids to correct values
+    walk(entity, (k: any, v: any, parent: any, path: any) => {
+      if (2 === size(path)) {
+        setprop(v, 'id', k)
+      }
+      return v
+    })
+
+    if (entity) {
+      ctx.utility.fetcher = (ctx: any, _fullurl: string, _fetchdef: any) => {
+        const { findparam, struct } = ctx.utility
+        const { getprop, clone, merge, keysof, size, select, delprop } = struct
+
+
+        function respond(status: number, data?: any, res?: any) {
+          const out = merge([
+            {
+              status,
+              statusText: 'OK',
+              json: async () => data,
+            },
+            res || {}
+          ])
+
+          const headers: any = out.headers || {}
+          out.headers = {
+            forEach(callback: any) {
+              Object.keys(headers).forEach((key) => {
+                callback(headers[key], key, this)
+              })
+            }
+          }
+
+          return out
+        }
+
+
+        const op = ctx.op
+        const entmap = entity[op.entity]
+
+        const qand: any[] = []
+        const q = { '`$AND`': qand }
+
+        for (let k of keysof(ctx.reqmatch)) {
+          const v = findparam(ctx, k)
+          const ka = getprop(op.alias, k)
+
+          let qor: any = [{ [k]: v }]
+          if (null != ka) {
+            qor.push({ [ka]: v })
+          }
+
+          qor = { '`$OR`': qor }
+
+          qand.push(qor)
+        }
+
+        if (ctx.ctrl.explain) {
+          ctx.ctrl.explain.test = { query: q }
+        }
+
+        if ('load' === op.name) {
+          const found = select(entmap, q)
+          const ent = found[0]
+          if (null == ent) {
+            return respond(404, undefined, { statusText: 'Not found' })
+          }
+          else {
+            delprop(ent, '$KEY')
+            return respond(200, clone(ent))
+          }
+        }
+        else if ('list' === op.name) {
+          const found = select(entmap, q)
+          if (null == found) {
+            return respond(404, undefined, { statusText: 'Not found' })
+          }
+          else {
+            found.map((ent: any) => delprop(ent, '$KEY'))
+            return respond(200, clone(found))
+          }
+        }
+        else if ('update' === op.name) {
+          const found = select(entmap, q)
+          const ent = found[0]
+          if (null == ent) {
+            return respond(404, undefined, { statusText: 'Not found' })
+          }
+          else {
+            merge([ent, (ctx.reqdata || {})])
+            delprop(ent, '$KEY')
+            return respond(200, clone(ent))
+          }
+        }
+        else if ('remove' === op.name) {
+          const found = select(entmap, q)
+          const ent = found[0]
+          if (null == ent) {
+            return respond(404, undefined, { statusText: 'Not found' })
+          }
+          else {
+            delprop(entmap, getprop(ent, 'id'))
+            return respond(200)
+          }
+        }
+        else if ('create' === op.name) {
+          const id = findparam(ctx, 'id')
+          if (null != id) {
+            const ent = clone(ctx.reqdata)
+            ent.id = id
+            setprop(entmap, 'id', ent)
+            delprop(ent, '$KEY')
+            return respond(200, clone(ent))
+          }
+          else {
+            return respond(400, undefined, { statusText: 'Missing id' })
+          }
+        }
+      }
+    }
+  }
+}
+
+
+
+
+export {
+  TestFeature
+}
+
+
+

package/project/.sdk/tm/ts/src/tsconfig.json

@@ -8,7 +8,7 @@
     "resolveJsonModule": true,
     "sourceMap": true,
     "strict": true,
-    "target": "es2021",
+    "target": "es2022",
     "declaration": true,
     "declarationDir": "../dist"
   }

package/project/.sdk/tm/ts/src/types.ts

@@ -0,0 +1,114 @@
+
+import { ProjectNameSDK } from './ProjectNameSDK'
+
+import { Utility } from './utility/Utility'
+
+type Context = {
+  ctrl: any
+  client: ProjectNameSDK
+  op: Operation
+  spec: Spec
+  result: Result
+  utility: Utility
+  entopts: any
+  options: any
+  config: any
+  response: any
+  entity: any
+  data: any
+  match: any
+  reqdata: any
+  reqmatch: any
+  work: any
+}
+
+
+type Operation = {
+  kind: string
+  entity: string
+  name: string
+  path: string
+  pathalt: ({ path: string } & Record<string, boolean>)[],
+  params: string[],
+  alias: Record<string, string>
+  state: Record<string, any>
+  reqform: any
+  resform: any
+  validate: {
+    params: Record<string, any>
+  }
+  check: Record<string, any>
+}
+
+
+type Spec = {
+  headers: Record<string, string>
+  alias: any
+  base: string
+  prefix: string
+  suffix: string
+  params: Record<string, string>
+  query: Record<string, string>
+  step: string
+  method: string
+  body: any
+  path: string
+  url?: string
+}
+
+
+type Result = {
+  ok: boolean
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body?: any
+  err?: any
+  resdata?: any
+  resmatch?: any
+}
+
+
+type Control = {
+  throw?: boolean
+  err?: any
+  explain?: any
+}
+
+
+type FeatureOptions = Record<string, any> | {
+  active: boolean
+}
+
+
+interface Feature {
+  version: string
+  name: string
+  active: boolean
+
+  init: (ctx: Context, options: FeatureOptions) => void | Promise<any>
+
+  PostConstruct: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PostConstructEntity: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  SetData: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  GetData: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  GetMatch: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+
+  PreOperation: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PreSpec: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PreRequest: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PreResponse: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PreResult: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+  PostOperation: (this: ProjectNameSDK, ctx: Context) => void | Promise<any>
+}
+
+
+
+export type {
+  Context,
+  Operation,
+  Spec,
+  Control,
+  FeatureOptions,
+  Feature,
+}

package/project/.sdk/tm/ts/src/utility/AddfeatureUtility.ts

@@ -0,0 +1,47 @@
+
+import { Context, Feature } from '../types'
+
+
+function addfeature(ctx: Context, f: Feature) {
+  const client = ctx.client
+  const struct = ctx.utility.struct
+  const setprop = struct.setprop
+  const getprop = struct.getprop
+
+  const fopts = getprop(f, '_options', {})
+  let added = false
+  const features = client._features
+
+  // TODO: make this a utility
+  if (fopts.__before__ || fopts.__after__ || fopts.__replace__) {
+
+    for (let i = 0; i < features.length; i++) {
+      let ef = client._features[i]
+      if (fopts.__before__ === ef.name) {
+        client._features = [...features.slice(0, i), f, ...features.slice(i)]
+        added = true
+        break
+      }
+      else if (fopts.__after__ === ef.name) {
+        client._features = [...features.slice(0, ++i), f, ...features.slice(i)]
+        added = true
+        break
+      }
+      else if (fopts.__replace__ === ef.name) {
+        client._features = setprop(features, i, f)
+        added = true
+        break
+      }
+    }
+  }
+
+  if (!added) {
+    client._features = setprop(features, features.length, f)
+  }
+
+}
+
+
+export {
+  addfeature
+}

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

@@ -0,0 +1,42 @@
+
+import { Context } from '../types'
+
+
+const HEADER_auth = 'authorization'
+
+const OPTION_apikey = 'apikey'
+
+const NOTFOUND = ''
+
+
+function auth(ctx: Context) {
+  const utility = ctx.utility
+
+  const struct = utility.struct
+  const getprop = struct.getprop
+  const setprop = struct.setprop
+  const delprop = struct.delprop
+
+  const client = ctx.client
+  const spec = ctx.spec
+
+  const headers = spec.headers
+
+  const options = client.options()
+
+  const apikey = getprop(options, OPTION_apikey, NOTFOUND)
+
+  if (NOTFOUND === apikey) {
+    delprop(headers, HEADER_auth)
+  }
+  else {
+    setprop(headers, HEADER_auth, options.auth.prefix + ' ' + apikey)
+  }
+
+  return spec
+}
+
+
+export {
+  auth
+}

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

@@ -0,0 +1,29 @@
+
+import { Context } from '../types'
+
+function body(ctx: Context) {
+  const { op, utility } = ctx
+  const { error, reqform } = utility
+
+  let body = undefined
+
+  if ('req' === op.kind) {
+    try {
+      body = reqform(ctx)
+
+      if (op.check.nobody && null == body) {
+        return error(ctx, new Error('Request body is empty.'))
+      }
+    }
+    catch (err) {
+      return error(ctx, err)
+    }
+  }
+
+  return body
+}
+
+export {
+  body
+}
+