@voxgig/sdkgen 0.24.0 → 0.26.1

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

@@ -1,81 +1,104 @@
 
-import type { Feature } from './types'
+import { inspect } from 'node:util'
 
-import { Config } from './Config'
+import type { Context, Feature } from './types'
+
+import { config } from './Config'
 import { Utility } from './utility/Utility'
 
 
 import { BaseFeature } from './feature/base/BaseFeature'
 
-const utility = new Utility()
 
+const stdutil = new Utility()
 
-class ProjectNameSDK {
-  #options: any
-  #utility = utility
 
+class ProjectNameSDK {
+  _mode: string = 'live'
+  _options: any
+  _utility = new Utility()
   _features: Feature[]
-
+  _rootctx: Context
 
   constructor(options?: any) {
 
-    const ctx = this.#utility.contextify({
+    this._rootctx = this._utility.makeContext({
       client: this,
-      utility: this.#utility,
-      config: Config,
+      utility: this._utility,
+      config,
       options,
+      shared: new WeakMap()
     })
 
-    this.#options = this.#utility.options(ctx)
+    this._options = this._utility.options(this._rootctx)
+
+    const struct = this._utility.struct
+    const getpath = struct.getpath
+    const items = struct.items
 
-    ctx.options = this.#options
+    if (true === getpath(this._options.feature, 'test.active')) {
+      this._mode = 'test'
+    }
+
+    this._rootctx.options = this._options
 
     this._features = []
 
-    const addfeature = this.#utility.addfeature
-    const initfeature = this.#utility.initfeature
+    const addfeature = this._utility.addfeature
+    const initfeature = this._utility.initfeature
 
-    // #BuildFeatures
+    items(this._options.feature, (fitem: [string, any]) => {
+      const fname = fitem[0]
+      const fopts = fitem[1]
+      if (fopts.active) {
+        addfeature(this._rootctx, this._rootctx.config.makeFeature(fname))
+      }
+    })
 
-    if (null != this.#options.extend) {
-      for (let f of this.#options.extend) {
-        addfeature(ctx, f)
+    if (null != this._options.extend) {
+      for (let f of this._options.extend) {
+        addfeature(this._rootctx, f)
       }
     }
 
     for (let f of this._features) {
-      initfeature(ctx, f)
+      initfeature(this._rootctx, f)
     }
 
-    const featurehook = this.#utility.featurehook
-    featurehook(ctx, 'PostConstruct')
+    const featureHook = this._utility.featureHook
+    featureHook(this._rootctx, 'PostConstruct')
   }
 
 
   options() {
-    return { ...this.#options }
+    return this._utility.struct.clone(this._options)
   }
 
 
   utility() {
-    return { ...this.#utility }
+    return this._utility.struct.clone(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
+  static test(testoptsarg?: any, sdkoptsarg?: any) {
+    const struct = stdutil.struct
+    const setpath = struct.setpath
+    const getdef = struct.getdef
+    const clone = struct.clone
+    const setprop = struct.setprop
+
+    const sdkopts = getdef(clone(sdkoptsarg), {})
+    const testopts = getdef(clone(testoptsarg), {})
+    setprop(testopts, 'active', true)
+    setpath(sdkopts, 'feature.test', testopts)
 
-    sdkopts = sdkopts || {}
-    sdkopts.feature = sdkopts.feature || {}
-    sdkopts.feature.test = testopts || {}
-    sdkopts.feature.test.active = true
+    const testsdk = new ProjectNameSDK(sdkopts)
+    testsdk._mode = 'test'
 
-    return new ProjectNameSDK(sdkopts)
+    return testsdk
   }
 
 
@@ -83,6 +106,19 @@ class ProjectNameSDK {
     return ProjectNameSDK.test(testopts, sdkopts)
   }
 
+
+  toJSON() {
+    return { name: 'ProjectName' }
+  }
+
+  toString() {
+    return 'ProjectName ' + this._utility.struct.jsonify(this.toJSON())
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
 }
 
 
@@ -91,11 +127,11 @@ class ProjectNameEntity {
 }
 
 
-
 const SDK = ProjectNameSDK
 
+
 export {
-  utility,
+  stdutil,
 
   BaseFeature,
   ProjectNameEntity,

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

@@ -1,10 +1,64 @@
 
+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 formatJSONSrc(jsonsrc: string) {
   return jsonsrc
     .replace(/([{:\[,])/g, '$1 ')
     .replace(/([}\]])/g, ' $1')
 }
 
+
+function formatJson(obj: any, flags?: { line?: boolean, margin?: number }): string {
+  const marginSize = flags?.margin ?? 0
+  const marginStr = ' '.repeat(marginSize)
+
+  let json: string
+
+  if (flags?.line) {
+    // One line with spaces for clarity
+    json = JSON.stringify(obj)
+      .replace(/([{:\[,])/g, '$1 ')
+      .replace(/([}\]])/g, ' $1')
+  }
+  else {
+    // Pretty printed with 2-space indentation
+    json = JSON.stringify(obj, null, 2)
+  }
+
+  // Add margin to the left of every line
+  if (marginSize > 0) {
+    json = json.split('\n').map(line => marginStr + line).join('\n')
+  }
+
+  return json
+}
+
+
+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 {
-  formatJSONSrc
+  clean,
+  formatJSONSrc,
+  formatJson,
+  projectPath,
 }

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

@@ -5,6 +5,9 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
+const S_NOT_FOUND = 'Not found'
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -18,137 +21,188 @@ class TestFeature extends BaseFeature {
     this._client = ctx.client
     this._options = options
 
-    // console.log('TEST FEATURE', this._options)
-
-    const { struct } = ctx.utility
-    const { walk, size, setprop, stringify } = struct
+    const struct = ctx.utility.struct
+    const walk = struct.walk
+    const size = struct.size
+    const setprop = struct.setprop
 
     const entity = this._options.entity
 
-    // Set entity ids to correct values
-    walk(entity, (k: any, v: any, parent: any, path: any) => {
+    this._client._mode = 'test'
+
+    // Ensure entity ids are correct.
+    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)
-              })
-            }
+    const self = this
+
+    function testFetcher(ctx: any, _fullurl: string, _fetchdef: any) {
+      const struct = ctx.utility.struct
+      const findparam = ctx.utility.findparam
+
+      const getprop = struct.getprop
+      const clone = struct.clone
+      const merge = struct.merge
+      const getelem = struct.getelem
+      const select = struct.select
+      const delprop = struct.delprop
+      const getdef = struct.getdef
+
+      function respond(status: number, data?: any, res?: any) {
+        const out = merge([
+          {
+            status,
+            statusText: 'OK',
+            json: async () => data,
+            body: 'not-used',
+          },
+          getdef(res, {})
+        ])
+
+        const headers: any = getprop(out, 'headers', {})
+
+        // JS specific iterator.
+        out.headers = {
+          forEach(callback: any) {
+            Object.keys(headers).forEach((key) => {
+              callback(headers[key], key, this)
+            })
           }
-
-          return out
         }
 
+        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 }
+      const op = ctx.op
+      const entmap = getprop(entity, op.entity, {})
 
-          qand.push(qor)
+      if ('load' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-
-        if (ctx.ctrl.explain) {
-          ctx.ctrl.explain.test = { query: q }
+        else {
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
         }
-
-        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 args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        if (null == found) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-        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 {
+          found.map((ent: any) => delprop(ent, '$KEY'))
+          const out = clone(found)
+          return respond(200, out)
         }
-        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 ('update' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
-        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 {
+          merge([ent, (ctx.reqdata || {})])
+          delprop(ent, '$KEY')
+          const out = clone(ent)
+          return respond(200, out)
         }
-        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' })
-          }
+      }
+      else if ('remove' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqmatch)
+        const found = select(entmap, args)
+        const ent = getelem(found, 0)
+        if (null == ent) {
+          return respond(404, undefined, { statusText: S_NOT_FOUND })
+        }
+        else {
+          delprop(entmap, getprop(ent, 'id'))
+          return respond(200)
+        }
+      }
+      else if ('create' === op.name) {
+        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        let id = findparam(ctx, 'id')
+        if (null == id) {
+          id = ((1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16) +
+            (1e4 * Math.random() | 0).toString(16)).padEnd(16, '0')
         }
+
+        const ent = clone(ctx.reqdata)
+        setprop(ent, 'id', id)
+        setprop(entmap, id, ent)
+        delprop(ent, '$KEY')
+        const out = clone(ent)
+        return respond(200, out)
       }
     }
+
+    ctx.utility.fetcher = testFetcher
   }
-}
 
 
+  buildArgs(ctx: any, op: any, args: any): any {
+    const struct = ctx.utility.struct
+    const findparam = ctx.utility.findparam
+
+    const getprop = struct.getprop
+    const keysof = struct.keysof
+    const getpath = struct.getpath
+    const getelem = struct.getelem
+    const select = struct.select
+    const transform = struct.transform
+    const isempty = struct.isempty
+
+    const opname = getprop(op, 'name')
+    const alt =
+      getelem(getpath(ctx.config, [
+        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'alts']), -1)
+
+    const reqd = transform(
+      select(getpath(alt, ['args', 'param']), { reqd: true }),
+      ['`$EACH`', '', '`$KEY.name`']
+    )
+
+    const qand: any[] = []
+    const q = { '`$AND`': qand }
+
+    for (let k of keysof(args)) {
+      if ('id' === k || !isempty(select(reqd, k))) {
+        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 }
+    }
+
+    return q
+  }
+}
 
 
 export {