@voxgig/sdkgen 0.21.0 → 0.23.0

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

@@ -0,0 +1,164 @@
+
+import { inspect } from 'node:util'
+
+import {
+  SdkNameSDK,
+  SdkNameEntity,
+} from '../SdkNameSDK'
+
+
+import type {
+  Operation,
+  Context,
+  Control,
+} from '../types'
+
+
+class EntityNameEntity {
+  #client: SdkNameSDK
+  #entopts: any
+  #utility: any
+  #data: any
+  #match: any
+
+  #_basectx: any
+
+  constructor(client: SdkNameSDK, entopts: any) {
+    // super()
+    entopts = entopts || {}
+    entopts.active = false !== entopts.active
+
+    this.#client = client
+    this.#entopts = entopts
+    this.#utility = client.utility()
+    this.#data = {}
+    this.#match = {}
+
+    const contextify = this.#utility.contextify
+    this.#_basectx = contextify({
+      entity: this,
+      client,
+      utility: this.#utility,
+      entopts,
+      options: client.options()
+    })
+
+    const featurehook = this.#utility.featurehook
+    featurehook(this.#_basectx, 'PostConstructEntity')
+  }
+
+  entopts() {
+    return { ...this.#entopts }
+  }
+
+  client() {
+    return this.#client
+  }
+
+  make() {
+    return new EntityNameEntity(this.#client, this.entopts())
+  }
+
+
+  data(this: any, data?: any) {
+    const featurehook = this.#utility.featurehook
+    const ctx = this.#_basectx
+
+    if (null != data) {
+      featurehook(ctx, 'SetData')
+      this.#data = { ...data }
+    }
+
+    let out = { ...this.#data }
+
+    featurehook(ctx, 'GetData')
+    return out
+  }
+
+
+  match(match?: any) {
+    const featurehook = this.#utility.featurehook
+    const ctx = this.#_basectx
+
+    if (null != match) {
+      featurehook(ctx, 'SetMatch')
+      this.#match = { ...match }
+    }
+
+    let out = { ...this.#match }
+
+    featurehook(ctx, 'GetMatch')
+    return out
+  }
+
+
+  toString() {
+    return 'EntityName ' + this.#utility.struct.jsonify(this.#data)
+  }
+
+  [inspect.custom]() {
+    return this.toString()
+  }
+
+
+  // #LoadOp
+
+  // #ListOp
+
+  // #CreateOp
+
+  // #UpdateOp
+
+  // #RemoveOp
+
+
+
+  #unexpected(this: any, ctx: Context, err: any) {
+    const ctrl = ctx.ctrl
+
+    ctrl.err = err
+
+    if (ctrl.explain) {
+      const { clean, struct } = this.#utility
+      const { delprop, clone } = struct
+
+      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, {
+          ...clone({ err: ctx.result.err }).err,
+          message: ctx.result.err.message,
+          stack: ctx.result.err.stack,
+        })
+      }
+
+      const cleanerr = clean(ctx, {
+        ...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
+  }
+
+}
+
+
+
+
+export {
+  EntityNameEntity
+}

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

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

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

@@ -0,0 +1,91 @@
+type Context = any
+type Operation = any
+type Control = any
+
+class EntityOperation {
+
+  // EJECT-START
+
+  async create(this: any, reqdata?: any, ctrl?: Control) {
+    let entity = this
+    let client = this.#client
+    const utility = this.#utility
+    const {
+      operator, spec, request, response, result, done, contextify, opify, featurehook
+    } = utility
+
+
+    let fres: Promise<any> | undefined = undefined
+
+    let op: Operation = opify({
+      entity: 'entityname',
+      name: 'create',
+      path: 'PATH',
+      pathalt: ['PATHALT'],
+      params: ['PARAM-LIST'],
+      alias: { 'ALIAS': 'MAP' },
+      state: {},
+      reqform: 'REQFORM',
+      resform: 'RESFORM',
+      validate: 'VALIDATE',
+    })
+
+    let ctx: Context = contextify({
+      ctrl,
+      op,
+      match: this.#match,
+      data: this.#data,
+      reqdata
+    }, this.#_basectx)
+
+    try {
+
+      // #PreOperation-Hook    
+
+      operator(ctx)
+
+
+      // #PreSpec-Hook
+
+      spec(ctx)
+
+
+      // #PreRequest-Hook
+
+      await request(ctx)
+
+
+      // #PreResponse-Hook
+
+      await response(ctx)
+
+
+      // #PreResult-Hook
+
+      result(ctx)
+
+
+      // #PostOperation-Hook
+
+      if (null != ctx.result.resdata) {
+        this.#data = ctx.result.resdata
+      }
+
+      return done(ctx)
+    }
+    catch (err: any) {
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+  #unexpected(this: any, ctx: Context, ctrl: any, err: any): any { return err }
+}

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

@@ -0,0 +1,92 @@
+type Context = any
+type Operation = any
+type Control = any
+
+class EntityOperation {
+
+  // EJECT-START
+
+  async list(this: any, reqmatch?: any, ctrl?: Control) {
+    let entity = this
+    let client = this.#client
+    const utility = this.#utility
+    const {
+      operator, spec, request, response, result, done, contextify, opify, featurehook
+    } = utility
+
+    let fres: Promise<any> | undefined = undefined
+
+    let op: Operation = opify({
+      entity: 'entityname',
+      name: 'list',
+      path: 'PATH',
+      pathalt: ['PATHALT'],
+      params: ['PARAM-LIST'],
+      alias: { 'ALIAS': 'MAP' },
+      state: {},
+      reqform: 'REQFORM',
+      resform: 'RESFORM',
+      validate: 'VALIDATE',
+    })
+
+    let ctx: Context = contextify({
+      ctrl,
+      op,
+      match: this.#match,
+      data: this.#data,
+      reqmatch
+    }, this.#_basectx)
+
+    try {
+
+      // #PreOperation-Hook    
+
+      operator(ctx)
+
+
+      // #PreSpec-Hook
+
+      spec(ctx)
+
+
+      // #PreRequest-Hook
+
+      await request(ctx)
+
+
+      // #PreResponse-Hook
+
+      await response(ctx)
+
+
+      // #PreResult-Hook
+
+      result(ctx)
+
+
+      // #PostOperation-Hook
+
+      if (null != ctx.result.resmatch) {
+        this.#match = ctx.result.resmatch
+      }
+
+      return done(ctx)
+    }
+    catch (err: any) {
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+  #unexpected(this: any, ctx: Context, ctrl: any, err: any): any { return err }
+
+}
+

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

@@ -0,0 +1,96 @@
+type Context = any
+type Operation = any
+type Control = any
+
+class EntityOperation {
+
+  // EJECT-START
+
+  async load(this: any, reqmatch?: any, ctrl?: Control) {
+
+    const entity = this
+    const client = this.#client
+    const utility = this.#utility
+    const {
+      operator, spec, request, response, result, done, contextify, opify, featurehook
+    } = utility
+
+    let fres: Promise<any> | undefined = undefined
+
+    const op: Operation = opify({
+      entity: 'entityname',
+      name: 'load',
+      path: 'PATH',
+      pathalt: ['PATHALT'],
+      params: ['PARAM-LIST'],
+      alias: { 'ALIAS': 'MAP' },
+      state: {},
+      reqform: 'REQFORM',
+      resform: 'RESFORM',
+      validate: 'VALIDATE',
+    })
+
+    let ctx: Context = contextify({
+      ctrl,
+      op,
+      match: this.#match,
+      data: this.#data,
+      reqmatch
+    }, this.#_basectx)
+
+    try {
+
+      // #PreOperation-Hook    
+
+      operator(ctx)
+
+
+      // #PreSpec-Hook
+
+      spec(ctx)
+
+
+      // #PreRequest-Hook
+
+      await request(ctx)
+
+
+      // #PreResponse-Hook
+
+      await response(ctx)
+
+
+      // #PreResult-Hook
+
+      result(ctx)
+
+
+      // #PostOperation-Hook
+
+      if (null != ctx.result.resmatch) {
+        this.#match = ctx.result.resmatch
+      }
+
+      if (null != ctx.result.resdata) {
+        this.#data = ctx.result.resdata
+      }
+
+      return done(ctx)
+    }
+    catch (err: any) {
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+  #unexpected(this: any, ctx: Context, ctrl: any, err: any): any { return err }
+}
+

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

@@ -0,0 +1,96 @@
+type Context = any
+type Operation = any
+type Control = any
+
+class EntityOperation {
+
+  // EJECT-START
+
+  async remove(this: any, reqmatch?: any, ctrl?: Control) {
+    let entity = this
+    let client = this.#client
+    const utility = this.#utility
+    const {
+      operator, spec, request, response, result, done, contextify, opify, featurehook
+    } = utility
+
+    let fres: Promise<any> | undefined = undefined
+
+    let op: Operation = opify({
+      entity: 'entityname',
+      name: 'remove',
+      path: 'PATH',
+      pathalt: ['PATHALT'],
+      params: ['PARAM-LIST'],
+      alias: { 'ALIAS': 'MAP' },
+      state: {},
+      reqform: 'REQFORM',
+      resform: 'RESFORM',
+      validate: 'VALIDATE',
+    })
+
+    let ctx: Context = contextify({
+      ctrl,
+      op,
+      match: this.#match,
+      data: this.#data,
+      reqmatch
+    }, this.#_basectx)
+
+    try {
+
+      // #PreOperation-Hook    
+
+      operator(ctx)
+
+
+      // #PreSpec-Hook
+
+      spec(ctx)
+
+
+      // #PreRequest-Hook
+
+      await request(ctx)
+
+
+      // #PreResponse-Hook
+
+      await response(ctx)
+
+
+      // #PreResult-Hook
+
+      result(ctx)
+
+
+      // #PostOperation-Hook
+
+      if (null != ctx.result.resmatch) {
+        this.#match = ctx.result.resmatch
+      }
+
+      if (null != ctx.result.resdata) {
+        this.#data = ctx.result.resdata
+      }
+
+      return done(ctx)
+    }
+    catch (err: any) {
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+  #unexpected(this: any, ctx: Context, ctrl: any, err: any): any { return err }
+
+}
+

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

@@ -0,0 +1,95 @@
+type Context = any
+type Operation = any
+type Control = any
+
+class EntityOperation {
+
+  // EJECT-START
+
+  async update(this: any, reqdata?: any, ctrl?: Control) {
+    let entity = this
+    let client = this.#client
+    const utility = this.#utility
+    const {
+      operator, spec, request, response, result, done, contextify, opify, featurehook
+    } = utility
+
+    let fres: Promise<any> | undefined = undefined
+
+    let op: Operation = opify({
+      entity: 'entityname',
+      name: 'update',
+      path: 'PATH',
+      params: ['PARAM-LIST'],
+      alias: { 'ALIAS': 'MAP' },
+      state: {},
+      reqform: 'REQFORM',
+      resform: 'RESFORM',
+      validate: 'VALIDATE',
+    })
+
+    let ctx: Context = contextify({
+      ctrl,
+      op,
+      match: this.#match,
+      data: this.#data,
+      reqdata
+    }, this.#_basectx)
+
+    try {
+
+      // #PreOperation-Hook    
+
+      operator(ctx)
+
+
+      // #PreSpec-Hook
+
+      spec(ctx)
+
+
+      // #PreRequest-Hook
+
+      await request(ctx)
+
+
+      // #PreResponse-Hook
+
+      await response(ctx)
+
+
+      // #PreResult-Hook
+
+      result(ctx)
+
+
+      // #PostOperation-Hook
+
+      if (null != ctx.result.resmatch) {
+        this.#match = ctx.result.resmatch
+      }
+
+      if (null != ctx.result.resdata) {
+        this.#data = ctx.result.resdata
+      }
+
+      return done(ctx)
+    }
+    catch (err: any) {
+      err = this.#unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+  #unexpected(this: any, ctx: Context, ctrl: any, err: any): any { return err }
+
+}
+