@voxgig/sdkgen 0.32.2 → 0.32.3

package/project/.sdk/src/cmp/js/fragment/Config.fragment.js

@@ -0,0 +1,55 @@
+
+const { BaseFeature } = require('./feature/base/BaseFeature')
+// #ImportFeatures
+
+
+const FEATURE_CLASS = {
+  // #FeatureClasses
+}
+
+
+class Config {
+
+  makeFeature(fn) {
+    const fc = FEATURE_CLASS[fn]
+    const fi = new fc()
+    // TODO: errors etc
+    return fi
+  }
+
+
+  main = {
+    name: 'ProjectName',
+  }
+
+
+  feature = {
+    // #FeatureConfigs
+  }
+
+
+  options = {
+    base: '$$main.kit.info.servers.0.url$$',
+
+    auth: {
+      prefix: '$$main.kit.config.auth.prefix$$',
+    },
+
+    headers: 'HEADERS',
+
+    entity: {
+      // #EntityConfigs
+    }
+  }
+
+
+  entity = 'ENTITYMAP'
+}
+
+
+const config = new Config()
+
+module.exports = {
+  config
+}
+

package/project/.sdk/src/cmp/js/fragment/Direct.test.fragment.js

@@ -0,0 +1,30 @@
+
+const envlocal = __dirname + '/../../../.env.local'
+require('dotenv').config({ quiet: true, path: [envlocal] })
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+
+
+const { ProjectNameSDK } = require('../../..')
+
+const {
+  envOverride,
+} = require('../../utility')
+
+
+describe('EntityNameDirect', async () => {
+
+  test('direct-exists', async () => {
+    const sdk = new ProjectNameSDK({
+      system: { fetch: async () => ({}) }
+    })
+    assert('function' === typeof sdk.direct)
+    assert('function' === typeof sdk.prepare)
+  })
+
+  // <[SLOT:direct]>
+})
+
+
+// <[SLOT:directSetup]>

package/project/.sdk/src/cmp/js/fragment/Entity.fragment.js

@@ -1,28 +1,52 @@
 
-class NameEntity {  
+const { inspect } = require('node:util')
+
+const {
+  SdkNameSDK,
+  SdkNameEntity,
+} = require('../SdkNameSDK')
+
+const {
+  Utility
+} = require('../utility/Utility')
+
+
+// TODO: needs Entity superclass
+class EntityNameEntity {
+  name = 'entityname'
+
   #client
-  #options
-  #features
   #utility
+  #entopts
   #data
   #match
-  
-  constructor(client, options) {
-    options = options || {}
-    options.active = false !== options.active
+
+  _entctx
+
+  constructor(client, entopts) {
+    // super()
+    entopts = entopts || {}
+    entopts.active = false !== entopts.active
 
     this.#client = client
-    this.#options = options
-    this.#features = client.features()
+    this.#entopts = entopts
     this.#utility = client.utility()
     this.#data = {}
     this.#match = {}
 
-    // #PostConstructEntity-Hook
+    const makeContext = this.#utility.makeContext
+
+    this._entctx = makeContext({
+      entity: this,
+      entopts,
+    }, client._rootctx)
+
+    const featureHook = this.#utility.featureHook
+    featureHook(this._entctx, 'PostConstructEntity')
   }
 
-  options() {
-    return { ...this.#options }
+  entopts() {
+    return { ...this.#entopts }
   }
 
   client() {
@@ -30,37 +54,56 @@ class NameEntity {
   }
 
   make() {
-    return new NameEntity(this.#client, this.options())
+    return new EntityNameEntity(this.#client, this.entopts())
   }
 
-  
+
   data(data) {
-    // NOTE: data can be mutated.
-    if(null != data) {
+    const struct = this.#utility.struct
+    const featureHook = this.#utility.featureHook
 
-      // #SetData-Hook
-      
-      this.#data = { ...data }
+    if (null != data) {
+      this.#data = struct.clone(data)
+      featureHook(this._entctx, 'SetData')
     }
 
-    let out = { ...this.#data }
-
-    // #GetData-Hook
+    featureHook(this._entctx, 'GetData')
+    let out = struct.clone(this.#data)
 
     return out
   }
 
-  
-  match() {
-    // NOTE: match cannot be mutated.
-    let out = { ...this.#match }
 
-    // #GetMatch-Hook
+  match(match) {
+    const struct = this.#utility.struct
+    const featureHook = this.#utility.featureHook
+
+    if (null != match) {
+      this.#match = struct.clone(match)
+      featureHook(this._entctx, 'SetMatch')
+    }
+
+    featureHook(this._entctx, 'GetMatch')
+    let out = struct.clone(this.#match)
 
     return out
   }
 
 
+  toJSON() {
+    const struct = this.#utility.struct
+    return struct.merge([{}, struct.getdef(this.#data, {}), { $entity: 'EntityName' }])
+  }
+
+  toString() {
+    return 'EntityName ' + this.#utility.struct.jsonify(this.#data)
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
+
   // #LoadOp
 
   // #ListOp
@@ -71,9 +114,57 @@ class NameEntity {
 
   // #RemoveOp
 
+
+  #unexpected(ctx, err) {
+    const clean = this.#utility.clean
+    const struct = this.#utility.struct
+
+    const delprop = struct.delprop
+    const clone = struct.clone
+    const merge = struct.merge
+
+    const ctrl = ctx.ctrl
+
+    ctrl.err = err
+
+    if (ctrl.explain) {
+      ctx.ctrl.explain = clean(ctx, ctx.ctrl.explain)
+      delprop(ctx.ctrl.explain.result, 'err')
+
+      if (null != ctx.result && null != ctx.result.err) {
+        ctrl.explain.err = clean(ctx, merge([
+          clone({ err: ctx.result.err }).err,
+          {
+            message: ctx.result.err.message,
+            stack: ctx.result.err.stack,
+          }]))
+      }
+
+      const cleanerr = clean(ctx, merge([
+        clone({ err }).err,
+        {
+          message: err.message,
+          stack: err.stack,
+        }]))
+
+      if (null == ctrl.explain.err) {
+        ctrl.explain.err = cleanerr
+      }
+      else if (ctrl.explain.err.message != cleanerr.message) {
+        ctrl.explain.unexpected = cleanerr
+      }
+    }
+
+    if (false === ctrl.throw) {
+      return undefined
+    }
+
+    return err
+  }
+
 }
 
 
 module.exports = {
-  NameEntity
+  EntityNameEntity
 }

package/project/.sdk/src/cmp/js/fragment/Entity.test.fragment.js

@@ -0,0 +1,39 @@
+
+const envlocal = __dirname + '/../../../.env.local'
+require('dotenv').config({ quiet: true, path: [envlocal] })
+
+const Path = require('node:path')
+const Fs = require('node:fs')
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+
+
+const { ProjectNameSDK, BaseFeature, stdutil } = require('../../..')
+
+const {
+  envOverride,
+  makeCtrl,
+  makeMatch,
+  makeReqdata,
+  makeStepData,
+  makeValid,
+} = require('../../utility')
+
+
+describe('EntityNameEntity', async () => {
+
+  test('instance', async () => {
+    const testsdk = ProjectNameSDK.test()
+    const ent = testsdk.EntityName()
+    assert(null != ent)
+  })
+
+
+  test('basic', async () => {
+    // <[SLOT:basic]>
+  })
+})
+
+
+// <[SLOT:basicSetup]>

package/project/.sdk/src/cmp/js/fragment/EntityCreateOp.fragment.js

@@ -1,61 +1,105 @@
-class EntityOperation { // REMOVED
-
-async create(data) {
-  let entity = this
-  let client = this.#client
-  const utility = this.#utility
-  const { operator, makeSpec, makeRequest, makeResponse, makeResult, error, struct, done } = utility
-  
-  let op = {
-    entity: 'Name',
-    name: 'create',
-    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, op, utility, entity }
 
-  
-  // #PreTarget-Hook    
+class EntityOperation {
+
+  #match
+  #data
+  #utility
+
+
+  // EJECT-START
+
+  async create(reqdata, ctrl) {
+
+    const utility = this.#utility
+    const {
+      makeContext,
+      done,
+      error,
+      featureHook,
+      makeTarget,
+      makeRequest,
+      makeResponse,
+      makeResult,
+      makeSpec,
+    } = utility
+
+    let fres = undefined
+
+    let ctx = makeContext({
+      opname: 'create',
+      ctrl,
+      match: this.#match,
+      data: this.#data,
+      reqdata
+    }, this._entctx)
+
+    try {
+      // #PreSelection-Hook
+
+      ctx.out.target = makeTarget(ctx)
+      if (ctx.out.target instanceof Error) {
+        return error(ctx, ctx.out.target)
+      }
 
-  await operator(ctx)
 
-  
-  // #PreSpec-Hook
+      // #PreSpec-Hook
 
-  this.#data = ctx.op.data
-  
-  await makeSpec(ctx)
+      ctx.out.spec = makeSpec(ctx)
+      if (ctx.out.spec instanceof Error) {
+        return error(ctx, ctx.out.spec)
+      }
 
-  
-  // #PreRequest-Hook
 
-  await makeRequest(ctx)
+      // #PreRequest-Hook
 
-  
-  // #PreResponse-Hook
+      ctx.out.request = await makeRequest(ctx)
+      if (ctx.out.request instanceof Error) {
+        return error(ctx, ctx.out.request)
+      }
 
-  await makeResponse(ctx)
 
-  
-  // #PreResult-Hook
+      // #PreResponse-Hook
 
-  await makeResult(ctx)
+      ctx.out.response = await makeResponse(ctx)
+      if (ctx.out.response instanceof Error) {
+        return error(ctx, ctx.out.response)
+      }
 
 
-  // #PostOperation-Hook
+      // #PreResult-Hook
 
-  if(null != ctx.result.resdata) {
-    this.#data = ctx.result.resdata
+      ctx.out.result = await makeResult(ctx)
+      if (ctx.out.result instanceof Error) {
+        return error(ctx, ctx.out.result)
+      }
+
+
+      // #PreDone-Hook
+
+      if (null != ctx.result) {
+        if (null != ctx.result.resdata) {
+          this.#data = ctx.result.resdata
+        }
+      }
+
+      return done(ctx)
+    }
+    catch (err) {
+      // #PreUnexpected-Hook
+
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
   }
 
-  return done(ctx)
-}
+  // EJECT-END
 
-} // REMOVED
+
+  #unexpected(ctx, err) { return err }
+}

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

@@ -1,57 +1,108 @@
-class EntityOperation { // REMOVED
-
-async list(match) {
-  let entity = this
-  let client = this.#client
-  const utility = this.#utility
-    const { operator, makeSpec, makeRequest, makeResponse, makeResult, error, struct, done } = utility
-  
-  let op = {
-    entity: 'Name',
-    name: 'list',
-    path: 'PATH',
-    params: ['PARAM-LIST'],
-    alias: {'ALIAS':'MAP'},
-    match,
-    data: this.#data,
-    state: {},
-    reqform: 'REQFORM',
-    resform: 'RESFORM',
-  }
 
-  let ctx = { client, entity, op, utility}
+class EntityOperation {
+
+  #match
+  #data
+  #utility
+
+
+  // EJECT-START
+
+  async list(reqmatch, ctrl) {
+
+    const utility = this.#utility
+
+    const {
+      makeContext,
+      done,
+      error,
+      featureHook,
+      makeTarget,
+      makeRequest,
+      makeResponse,
+      makeResult,
+      makeSpec,
+    } = utility
+
+    let fres = undefined
+
+    let ctx = makeContext({
+      opname: 'list',
+      ctrl,
+      match: this.#match,
+      data: this.#data,
+      reqmatch
+    }, this._entctx)
+
+    try {
+      // #PreSelection-Hook
+
+      ctx.out.target = makeTarget(ctx)
+      if (ctx.out.target instanceof Error) {
+        return error(ctx, ctx.out.target)
+      }
 
-  
-  // #PreTarget-Hook    
 
-  await operator(ctx)
+      // #PreSpec-Hook
 
-  
-  // #PreSpec-Hook
+      ctx.out.spec = makeSpec(ctx)
+      if (ctx.out.spec instanceof Error) {
+        return error(ctx, ctx.out.spec)
+      }
 
-  this.#match = ctx.op.match
-  
-  await makeSpec(ctx)
 
-  
-  // #PreRequest-Hook
+      // #PreRequest-Hook
 
-  await makeRequest(ctx)
+      ctx.out.request = await makeRequest(ctx)
+      if (ctx.out.request instanceof Error) {
+        return error(ctx, ctx.out.request)
+      }
 
-  
-  // #PreResponse-Hook
 
-  await makeResponse(ctx)
+      // #PreResponse-Hook
 
-  
-  // #PreResult-Hook
+      ctx.out.response = await makeResponse(ctx)
+      if (ctx.out.response instanceof Error) {
+        return error(ctx, ctx.out.response)
+      }
+
+
+      // #PreResult-Hook
+
+      ctx.out.result = await makeResult(ctx)
+      if (ctx.out.result instanceof Error) {
+        return error(ctx, ctx.out.result)
+      }
+
+
+      // #PreDone-Hook
+
+      if (null != ctx.result) {
+        if (null != ctx.result.resmatch) {
+          this.#match = ctx.result.resmatch
+        }
+      }
+
+      return done(ctx)
+    }
+    catch (err) {
+      // #PreUnexpected-Hook
+
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
 
-  await makeResult(ctx)
+  // EJECT-END
 
 
-  // #PostOperation-Hook
+  #unexpected(_ctx, err) { return err }
 
-  return done(ctx)
 }
 
-} // REMOVED