@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -102,17 +102,22 @@ class ProjectNameEntityBase {
   //     streaming feature when active, else the materialised items);
   //   - outbound (upload): pass an async-iterable `body` to stream a request
   //     payload — it is attached to the request so the transport can send it;
-  //   - `ctrl` (pipeline control) and `signal` (AbortSignal) are honoured.
+  //   - `ctrl` (pipeline control) and `signal` (AbortSignal) are honoured:
+  //     an abort cancels the request and ends the iteration.
   async *stream(action, args, callopts) {
     const utility = this._utility
     const {
       makeContext, done, featureHook,
-      makePoint, makeSpec, makeRequest, makeResponse, makeResult,
+      // The registry name is `makeError`; `error` is the local alias.
+      makeError: error,
     } = utility
 
     callopts = callopts || {}
-    const signal = callopts.signal
     const ctrl = { ...(callopts.ctrl || {}), stream: callopts }
+    if (null != callopts.signal) {
+      ctrl.signal = callopts.signal
+    }
+    const signal = ctrl.signal
 
     const ctx = makeContext({
       opname: action,
@@ -130,30 +135,12 @@ class ProjectNameEntityBase {
     }
 
     try {
-      let fres
-
-      fres = featureHook(ctx, 'PrePoint'); if (fres instanceof Promise) { await fres }
-      ctx.out.point = makePoint(ctx); if (ctx.out.point instanceof Error) { throw ctx.out.point }
-
-      fres = featureHook(ctx, 'PreSpec'); if (fres instanceof Promise) { await fres }
-      ctx.out.spec = makeSpec(ctx); if (ctx.out.spec instanceof Error) { throw ctx.out.spec }
-
-      fres = featureHook(ctx, 'PreRequest'); if (fres instanceof Promise) { await fres }
-      ctx.out.request = await makeRequest(ctx); if (ctx.out.request instanceof Error) { throw ctx.out.request }
-
-      fres = featureHook(ctx, 'PreResponse'); if (fres instanceof Promise) { await fres }
-      ctx.out.response = await makeResponse(ctx); if (ctx.out.response instanceof Error) { throw ctx.out.response }
-
-      fres = featureHook(ctx, 'PreResult'); if (fres instanceof Promise) { await fres }
-      ctx.out.result = await makeResult(ctx); if (ctx.out.result instanceof Error) { throw ctx.out.result }
-
-      fres = featureHook(ctx, 'PreDone'); if (fres instanceof Promise) { await fres }
-
+      const failed = await this._streamSteps(ctx)
       const result = ctx.result
 
       // Inbound: prefer the streaming feature's incremental iterator; else
       // fall back to the materialised items so `stream` always yields.
-      if (result && 'function' === typeof result.stream) {
+      if (null == failed && result && 'function' === typeof result.stream) {
         // done() does not run on this path, so its record is cleaned here.
         utility.cleanExplain(ctx)
         for await (const item of result.stream()) {
@@ -162,7 +149,8 @@ class ProjectNameEntityBase {
         }
       }
       else {
-        const data = done(ctx)
+        // A failed step leaves through makeError, as an operation's does.
+        const data = null == failed ? done(ctx) : error(ctx, failed)
         const items = Array.isArray(data) ? data : (null == data ? [] : [data])
         for (const item of items) {
           if (signal && signal.aborted) { return }
@@ -171,12 +159,50 @@ class ProjectNameEntityBase {
       }
     }
     catch (err) {
+      // What a hook throws here must not escape the cleaning below.
+      try {
+        const fres = featureHook(ctx, 'PreUnexpected')
+        if (fres instanceof Promise) { await fres }
+      }
+      catch (hookerr) {
+        err = hookerr
+      }
+
+      // An abort ends the stream quietly, whenever it lands.
       const e = this._unexpected(ctx, err)
-      if (e) { throw e }
+      if (e && true !== signal?.aborted) { throw e }
     }
   }
 
 
+  // The steps an operation runs, with their hooks; the first that fails
+  // hands back its error.
+  async _streamSteps(ctx) {
+    const {
+      featureHook, makePoint, makeSpec, makeRequest, makeResponse, makeResult,
+    } = this._utility
+
+    let fres
+
+    fres = featureHook(ctx, 'PrePoint'); if (fres instanceof Promise) { await fres }
+    ctx.out.point = makePoint(ctx); if (ctx.out.point instanceof Error) { return ctx.out.point }
+
+    fres = featureHook(ctx, 'PreSpec'); if (fres instanceof Promise) { await fres }
+    ctx.out.spec = makeSpec(ctx); if (ctx.out.spec instanceof Error) { return ctx.out.spec }
+
+    fres = featureHook(ctx, 'PreRequest'); if (fres instanceof Promise) { await fres }
+    ctx.out.request = await makeRequest(ctx); if (ctx.out.request instanceof Error) { return ctx.out.request }
+
+    fres = featureHook(ctx, 'PreResponse'); if (fres instanceof Promise) { await fres }
+    ctx.out.response = await makeResponse(ctx); if (ctx.out.response instanceof Error) { return ctx.out.response }
+
+    fres = featureHook(ctx, 'PreResult'); if (fres instanceof Promise) { await fres }
+    ctx.out.result = await makeResult(ctx); if (ctx.out.result instanceof Error) { return ctx.out.result }
+
+    fres = featureHook(ctx, 'PreDone'); if (fres instanceof Promise) { await fres }
+  }
+
+
   toJSON() {
     const struct = this._utility.struct
   // The marker is NAMESPACED. It used to be `entity$` — a short, generic

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

@@ -7,7 +7,7 @@ class EntityOperation {
   /**
    * @param {EntityNameCreateData} [reqdata]
    * @param {Object} [ctrl]
-   * @returns {Promise<EntityName>}
+   * @returns {Promise<EntyClass>}
    */
   async create(reqdata, ctrl) {
 

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

@@ -7,7 +7,7 @@ class EntityOperation {
   /**
    * @param {EntityNameListMatch} [reqmatch]
    * @param {Object} [ctrl]
-   * @returns {Promise<EntityName[]>}
+   * @returns {Promise<EntyClass[]>}
    */
   async list(reqmatch, ctrl) {
 

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

@@ -7,7 +7,7 @@ class EntityOperation {
   /**
    * @param {EntityNameLoadMatch} [reqmatch]
    * @param {Object} [ctrl]
-   * @returns {Promise<EntityName>}
+   * @returns {Promise<EntyClass>}
    */
   async load(reqmatch, ctrl) {
 

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

@@ -0,0 +1,129 @@
+
+class EntityOperation {
+
+
+  // EJECT-START
+
+  /**
+   * @param {EntityNameUpdateData} [reqdata]
+   * @param {Object} [ctrl]
+   * @returns {Promise<EntyClass>}
+   */
+  async patch(reqdata, ctrl) {
+
+    const utility = this._utility
+
+    const {
+      makeContext,
+      done,
+      // The registry name is `makeError`; `error` is the local alias.
+      makeError: error,
+      featureHook,
+      makePoint,
+      makeRequest,
+      makeResponse,
+      makeResult,
+      makeSpec,
+    } = utility
+
+    let fres = undefined
+
+    let ctx = makeContext({
+      opname: 'patch',
+      ctrl,
+      match: this._match,
+      data: this._data,
+      reqdata
+    }, this._entctx)
+
+    try {
+
+      // #PrePoint-Hook
+
+      ctx.out.point = makePoint(ctx)
+      if (ctx.out.point instanceof Error) {
+        return error(ctx, ctx.out.point)
+      }
+
+
+      // #PreSpec-Hook
+
+      ctx.out.spec = makeSpec(ctx)
+      if (ctx.out.spec instanceof Error) {
+        return error(ctx, ctx.out.spec)
+      }
+
+
+      // #PreRequest-Hook
+
+      ctx.out.request = await makeRequest(ctx)
+      if (ctx.out.request instanceof Error) {
+        return error(ctx, ctx.out.request)
+      }
+
+
+      // #PreResponse-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
+        }
+
+        if (null != ctx.result.resdata) {
+          this._data = ctx.result.resdata
+        }
+      }
+
+      const out = done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data — the record
+      // has just been absorbed into this instance and is reached through
+      // data(). `done` still runs: it completes the pipeline and raises on
+      // failure, and when throwing is disabled it hands back the error
+      // payload, which passes through unchanged. See AGENTS.md "Entity
+      // operations return ENTITIES".
+      return (ctx.result && ctx.result.ok) ? this : out
+    }
+    catch (err) {
+      // What a hook throws here must not escape the cleaning below.
+      try {
+        // #PreUnexpected-Hook
+      }
+      catch (hookerr) {
+        err = hookerr
+      }
+
+      err = this._unexpected(ctx, err)
+
+      if (err) {
+        throw err
+      }
+      else {
+        return undefined
+      }
+    }
+  }
+
+  // EJECT-END
+
+
+  _unexpected(ctx, err) { return err }
+
+}
+

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

@@ -7,7 +7,7 @@ class EntityOperation {
   /**
    * @param {EntityNameRemoveMatch} [reqmatch]
    * @param {Object} [ctrl]
-   * @returns {Promise<EntityName>}
+   * @returns {Promise<EntyClass>}
    */
   async remove(reqmatch, ctrl) {
 

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

@@ -7,7 +7,7 @@ class EntityOperation {
   /**
    * @param {EntityNameUpdateData} [reqdata]
    * @param {Object} [ctrl]
-   * @returns {Promise<EntityName>}
+   * @returns {Promise<EntyClass>}
    */
   async update(reqdata, ctrl) {
 

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

@@ -3,6 +3,9 @@ const { inspect } = require('node:util')
 
 const { config } = require('./Config')
 const { Utility } = require('./utility/Utility')
+const { unreadableBody } = require('./utility/ResultBodyUtility')
+const { abortError } = require('./utility/MakeRequestUtility')
+const { allowed } = require('./utility/PrepareMethodUtility')
 const { ProjectNameEntityBase } = require('./ProjectNameEntityBase')
 
 
@@ -124,6 +127,12 @@ class ProjectNameSDK {
     }, this._rootctx)
 
     const options = this._options
+    const method = String(fetchargs.method || 'GET').toUpperCase()
+
+    if (!allowed(options.allow.method, method)) {
+      return ctx.error('spec_method_allow', 'Method "' + method +
+        '" not allowed by SDK option allow.method value: "' + options.allow.method + '"')
+    }
 
     // Build spec directly from SDK options + user-provided fetch args.
     const spec = {
@@ -131,7 +140,7 @@ class ProjectNameSDK {
       prefix: options.prefix,
       suffix: options.suffix,
       path: fetchargs.path || '',
-      method: fetchargs.method || 'GET',
+      method,
       params: fetchargs.params || {},
       query: fetchargs.query || {},
       headers: prepareHeaders(ctx),
@@ -165,7 +174,7 @@ class ProjectNameSDK {
   // Blocking it means denying BOTH the 'direct' and 'graphql' tokens, since
   // either one reaches the same endpoint.
   async direct(fetchargs) {
-    if (!this._options.allow.op.includes('direct')) {
+    if (!allowed(this._options.allow.op, 'direct')) {
       return {
         ok: false,
         err: new Error('ProjectNameSDK: direct: operation not allowed by' +
@@ -189,7 +198,7 @@ class ProjectNameSDK {
 
     const fetchdef = await this.prepare(fetchargs)
     if (fetchdef instanceof Error) {
-      return fetchdef
+      return { ok: false, err: utility.clean(this._rootctx, fetchdef) }
     }
 
     let ctx = makeContext({
@@ -198,13 +207,17 @@ class ProjectNameSDK {
     }, this._rootctx)
 
     try {
+      if (true === fetchdef.signal?.aborted) {
+        throw fetchdef.signal.reason
+      }
+
       const fetched = await fetcher(ctx, fetchdef.url, fetchdef)
 
       if (null == fetched) {
         return { ok: false, err: ctx.error('direct_no_response', 'response: undefined') }
       }
       else if (fetched instanceof Error) {
-        return { ok: false, err: utility.clean(ctx, fetched) }
+        return { ok: false, err: utility.clean(ctx, abortError(ctx, fetched)) }
       }
 
       const status = fetched.status
@@ -219,26 +232,41 @@ class ProjectNameSDK {
       const noBody = 204 === status || 304 === status || '0' === String(contentLength)
 
       let json = undefined
+      let err = undefined
       if (!noBody) {
+        let text = undefined
         try {
-          json = 'function' === typeof fetched.json ? await fetched.json() : fetched.json
+          const raw = fetched
+          if ('function' === typeof raw.text) {
+            text = await raw.text()
+            json = '' === text.trim() ? undefined : JSON.parse(text)
+          }
+          else {
+            json = 'function' === typeof fetched.json ? await fetched.json() : fetched.json
+          }
         }
         catch (parseErr) {
-          // Body wasn't valid JSON — surface the raw response rather than
-          // throwing. data stays undefined; callers can inspect status/headers.
-          json = undefined
+          if ('SyntaxError' !== parseErr?.name) {
+            throw parseErr
+          }
+          err = unreadableBody(ctx, {
+            status, headers, text: text ?? parseErr.text, sent: fetchdef.headers,
+            failed: 200 <= status && status < 300 ? undefined :
+              ctx.error('request_status', 'request: ' + status + ': ' + fetched.statusText),
+          })
         }
       }
 
       return {
-        ok: status >= 200 && status < 300,
+        ok: null == err && status >= 200 && status < 300,
         status,
         headers: fetched.headers,
         data: json,
+        ...(null == err ? {} : { err: utility.clean(ctx, err) }),
       }
     }
     catch (err) {
-      return { ok: false, err: utility.clean(ctx, err) }
+      return { ok: false, err: utility.clean(ctx, abortError(ctx, err)) }
     }
   }
 
@@ -259,7 +287,7 @@ class ProjectNameSDK {
   async graphql(query, variables, ctrl) {
     const options = this._options
 
-    if (!options.allow.op.includes('graphql')) {
+    if (!allowed(options.allow.op, 'graphql')) {
       return {
         ok: false,
         err: new Error('ProjectNameSDK: graphql: operation not allowed by' +
@@ -274,10 +302,6 @@ class ProjectNameSDK {
       ctrl,
     })
 
-    if (res instanceof Error) {
-      return res
-    }
-
     // Errors are read BEFORE any status check: a GraphQL parse or validation
     // failure comes back as HTTP 400 carrying the standard { errors: [...] }
     // body, and the raw path represents a non-2xx as { ok: false } with no

package/project/.sdk/src/cmp/js/utility_js.ts

@@ -7,6 +7,7 @@ import {
   canonScalarKey,
   each,
   opParams,
+  jsQuote,
 } from '@voxgig/sdkgen'
 
 import {
@@ -54,7 +55,7 @@ function exampleValue(entity: any, op: any, paramName: string, placeholder: stri
   if ('NULL' === key) {
     return 'null'
   }
-  return `'${placeholder}'`
+  return jsQuote(placeholder)
 }
 
 

package/project/.sdk/src/cmp/kotlin/Config_kotlin.ts

@@ -72,6 +72,10 @@ const Config = cmp(async function Config(props: any) {
   const options: Record<string, any> = {
     base: baseUrl,
   }
+  // The declared defaults makeOptions fills a templated base URL from.
+  if (null != configDef.options.server) {
+    options.server = configDef.options.server
+  }
   if (authActive) {
     const auth: Record<string, any> = { prefix: authPrefix }
     // `basic` joins them for the same reason: the generated prepareAuth

package/project/.sdk/src/cmp/kotlin/EntityTypes_kotlin.ts

@@ -124,7 +124,7 @@ object ${model.const.Name}Types {
       })), log)
 
       const ops = ent.op || {}
-      ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+      ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
         if (null == ops[opname]) {
           return
         }

package/project/.sdk/src/cmp/kotlin/Entity_kotlin.ts

@@ -44,7 +44,7 @@ const Entity = cmp(function Entity(props: any) {
       const opnames = Object.keys(entity.op || {})
 
       const opfrags =
-        (['load', 'list', 'create', 'update', 'remove']
+        (['load', 'list', 'create', 'update', 'patch', 'remove']
           .reduce((a: any, opname: string) =>
           (a['// #' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ?

package/project/.sdk/src/cmp/kotlin/Main_kotlin.ts

@@ -5,6 +5,7 @@ import {
   cmp, each,
   File, Copy, Folder, Fragment,
   TEST_CONTROL_EXCLUDE,
+  inactiveFeatureExcludes,
   pluginExcludes
 } from '@voxgig/sdkgen'
 
@@ -51,7 +52,8 @@ const Main = cmp(async function Main(props: any) {
   // token used throughout the templates (package/import statements).
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE,
+      ...inactiveFeatureExcludes(props.ctx$, target), ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
       KOTLINPACKAGE: kotlinpackage,