@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/dart/lib/utility/MakeRequestUtility.dart

@@ -0,0 +1,63 @@
+import 'dart:async';
+
+import '../Response.dart';
+import '../Result.dart';
+
+import 'ErrUtility.dart';
+
+Future<dynamic> makeRequest(dynamic ctx) async {
+  // PreRequest feature hook has already provided a result.
+  if (null != ctx.out['request']) {
+    return ctx.out['request'];
+  }
+
+  final spec = ctx.spec;
+  final utility = ctx.utility;
+  final fetcher = utility.fetcher;
+  final makeFetchDef = utility.makeFetchDef;
+
+  var response = Response({});
+
+  final result = Result({});
+
+  ctx.result = result;
+
+  if (null == spec) {
+    return ctx.error(
+        'request_no_spec', 'Expected context spec property to be defined.');
+  }
+
+  try {
+    final fetchdef = makeFetchDef(ctx);
+    if (iserr(fetchdef)) {
+      throw fetchdef;
+    }
+
+    if (null != ctx.ctrl['explain']) {
+      ctx.ctrl['explain']['fetchdef'] = fetchdef;
+    }
+
+    spec.step = 'prerequest';
+
+    final fetched =
+        await Future.value(fetcher(ctx, fetchdef['url'], fetchdef));
+
+    if (null == fetched) {
+      response = Response({
+        'err': ctx.error('request_no_response', 'response: undefined')
+      });
+    } else if (iserr(fetched)) {
+      response = Response({'err': fetched});
+    } else {
+      response = Response(fetched);
+    }
+  } catch (err) {
+    response.err = err;
+  }
+
+  spec.step = 'postrequest';
+
+  ctx.response = response;
+
+  return response;
+}

package/project/.sdk/tm/dart/lib/utility/MakeResponseUtility.dart

@@ -0,0 +1,54 @@
+import 'dart:async';
+
+Future<dynamic> makeResponse(dynamic ctx) async {
+  // PreResponse feature hook has already provided a result.
+  if (null != ctx.out['response']) {
+    return ctx.out['response'];
+  }
+
+  final utility = ctx.utility;
+  final resultBasic = utility.resultBasic;
+  final resultHeaders = utility.resultHeaders;
+  final resultBody = utility.resultBody;
+  final transformResponse = utility.transformResponse;
+
+  final spec = ctx.spec;
+  final result = ctx.result;
+  final response = ctx.response;
+
+  if (null == spec) {
+    return ctx.error(
+        'response_no_spec', 'Expected context spec property to be defined.');
+  }
+
+  if (null == response) {
+    return ctx.error('response_no_response',
+        'Expected context response property to be defined.');
+  }
+
+  if (null == result) {
+    return ctx.error('response_no_result',
+        'Expected context result property to be defined.');
+  }
+
+  spec.step = 'response';
+
+  try {
+    resultBasic(ctx);
+    resultHeaders(ctx);
+    await Future.value(resultBody(ctx));
+    transformResponse(ctx);
+
+    if (null == result.err) {
+      result.ok = true;
+    }
+  } catch (err) {
+    result.err = err;
+  }
+
+  if (null != ctx.ctrl['explain']) {
+    ctx.ctrl['explain']['result'] = result;
+  }
+
+  return response;
+}

package/project/.sdk/tm/dart/lib/utility/MakeResultUtility.dart

@@ -0,0 +1,49 @@
+dynamic makeResult(dynamic ctx) {
+  // PreResult feature hook has already provided a result.
+  if (null != ctx.out['result']) {
+    return ctx.out['result'];
+  }
+
+  final utility = ctx.utility;
+  final transformResponse = utility.transformResponse;
+
+  final op = ctx.op;
+  final entity = ctx.entity;
+
+  final spec = ctx.spec;
+  final result = ctx.result;
+
+  if (null == spec) {
+    return ctx.error(
+        'result_no_spec', 'Expected context spec property to be defined.');
+  }
+
+  if (null == result) {
+    return ctx.error(
+        'result_no_result', 'Expected context result property to be defined.');
+  }
+
+  spec.step = 'result';
+
+  transformResponse(ctx);
+
+  if ('list' == op.name) {
+    final resdata = result.resdata;
+    result.resdata = [];
+
+    if (resdata is List && 0 < resdata.length) {
+      for (final entry in resdata) {
+        final ent = entity.make();
+        ent.data(entry);
+        result.resdata.add(ent);
+      }
+    }
+  }
+
+  if (null != ctx.ctrl['explain']) {
+    ctx.ctrl['explain']['result'] = result;
+  }
+
+  // NOTE: returns processed result.
+  return result;
+}

package/project/.sdk/tm/dart/lib/utility/MakeSpecUtility.dart

@@ -0,0 +1,61 @@
+import '../Spec.dart';
+
+import 'ErrUtility.dart';
+
+// Create request specification.
+dynamic makeSpec(dynamic ctx) {
+  if (null != ctx.out['spec']) {
+    return ctx.spec = ctx.out['spec'];
+  }
+
+  final point = ctx.point;
+  final options = ctx.options;
+  final utility = ctx.utility;
+
+  final prepareMethod = utility.prepareMethod;
+  final prepareParams = utility.prepareParams;
+  final prepareQuery = utility.prepareQuery;
+  final prepareHeaders = utility.prepareHeaders;
+  final prepareBody = utility.prepareBody;
+  final preparePath = utility.preparePath;
+  final prepareAuth = utility.prepareAuth;
+
+  ctx.spec = Spec({
+    'base': options['base'], // string, URL endpoint base prefix,
+    'prefix': options['prefix'],
+    'parts': point.parts,
+    'suffix': options['suffix'],
+    'step': 'start',
+  });
+
+  ctx.spec.method = prepareMethod(ctx);
+
+  final allowmethod = (options['allow']?['method'] ?? '').toString();
+  if (!allowmethod.contains(ctx.spec.method.toString())) {
+    return ctx.error(
+        'spec_method_allow',
+        'Method "' +
+            ctx.spec.method.toString() +
+            '" not allowed by SDK option allow.method value: "' +
+            allowmethod +
+            '"');
+  }
+
+  ctx.spec.params = prepareParams(ctx);
+  ctx.spec.query = prepareQuery(ctx);
+  ctx.spec.headers = prepareHeaders(ctx);
+  ctx.spec.body = prepareBody(ctx);
+  ctx.spec.path = preparePath(ctx);
+
+  if (null != ctx.ctrl['explain']) {
+    ctx.ctrl['explain']['spec'] = ctx.spec;
+  }
+
+  final spec = prepareAuth(ctx);
+
+  if (!iserr(spec)) {
+    ctx.spec = spec;
+  }
+
+  return spec;
+}

package/project/.sdk/tm/dart/lib/utility/MakeUrlUtility.dart

@@ -0,0 +1,51 @@
+import 'voxgig_struct.dart' as vs;
+
+dynamic makeUrl(dynamic ctx) {
+  final spec = ctx.spec;
+  final result = ctx.result;
+
+  if (null == spec) {
+    return ctx.error(
+        'url_no_spec', 'Expected context spec property to be defined.');
+  }
+
+  if (null == result) {
+    return ctx.error(
+        'url_no_result', 'Expected context result property to be defined.');
+  }
+
+  // TODO: use parts to avoid regexp?
+  var url =
+      vs.join([spec.base, spec.prefix, spec.path, spec.suffix], '/', true);
+  final resmatch = <String, dynamic>{};
+
+  final params = spec.params;
+
+  for (final item in vs.items(params)) {
+    final key = item[0];
+    final val = item[1];
+    if (null != val) {
+      url = url.replaceFirst(
+          RegExp('\\{' + vs.escre(key) + '\\}'), vs.escurl(val.toString()));
+      resmatch[key] = val;
+    }
+  }
+
+  // Append query string from spec.query. Entity ops populate this via
+  // PrepareQueryUtility from the operation's reqmatch; direct() callers
+  // pass it as fetchargs.query.
+  var qsep = '?';
+  for (final item in vs.items(spec.query)) {
+    final key = item[0];
+    final val = item[1];
+    if (null != val) {
+      url = url + qsep + vs.escurl(key) + '=' + vs.escurl(val.toString());
+      qsep = '&';
+      resmatch[key] = val;
+    }
+  }
+
+  result.resmatch = resmatch;
+
+  return url;
+}

package/project/.sdk/tm/dart/lib/utility/ParamUtility.dart

@@ -0,0 +1,56 @@
+import 'voxgig_struct.dart' as vs;
+
+/* Find value of a match parameter, possibly using an alias.
+ *
+ * The match parameter may have an alias key. For example, the parameter
+ * `foo_id` may be aliased to `id` in the entity data.
+ *
+ * This function returns null rather than failing.
+ */
+dynamic param(dynamic ctx, dynamic paramdef) {
+  final point = ctx.point;
+  final spec = ctx.spec;
+  final match = ctx.match;
+  final reqmatch = ctx.reqmatch;
+  final data = ctx.data;
+  final reqdata = ctx.reqdata;
+
+  // TODO: review this search algorithm
+
+  final key =
+      paramdef is String ? paramdef : vs.getprop(paramdef, 'name');
+
+  final akey = null == point ? null : vs.getprop(point.alias, key);
+
+  dynamic val = vs.getprop(reqmatch, key);
+
+  if (null == val) {
+    val = vs.getprop(match, key);
+  }
+
+  if (null == val && null != akey) {
+    if (null != spec) {
+      vs.setprop(spec.alias, akey, key);
+    }
+
+    val = vs.getprop(reqmatch, akey);
+  }
+
+  if (null == val) {
+    val = vs.getprop(reqdata, key);
+  }
+
+  if (null == val) {
+    val = vs.getprop(data, key);
+  }
+
+  if (null == val && null != akey) {
+    val = vs.getprop(reqdata, akey);
+
+    if (null == val) {
+      val = vs.getprop(data, akey);
+    }
+  }
+
+  return val;
+}

package/project/.sdk/tm/dart/lib/utility/PrepareAuthUtility.dart

@@ -0,0 +1,46 @@
+import 'voxgig_struct.dart' as vs;
+
+const HEADER_auth = 'authorization';
+
+const OPTION_apikey = 'apikey';
+
+const NOTFOUND = '__NOTFOUND__';
+
+dynamic prepareAuth(dynamic ctx) {
+  final client = ctx.client;
+  final spec = ctx.spec;
+
+  if (null == spec) {
+    return ctx.error(
+        'auth_no_spec', 'Expected context spec property to be defined.');
+  }
+
+  final headers = spec.headers;
+
+  final options = client.options();
+
+  // Public APIs that need no auth omit the options.auth block entirely.
+  if (null == vs.getprop(options, 'auth')) {
+    vs.delprop(headers, HEADER_auth);
+    return spec;
+  }
+
+  final prefix = vs.getpath(options, 'auth.prefix');
+
+  final apikey = vs.getprop(options, OPTION_apikey, NOTFOUND);
+
+  if (NOTFOUND == apikey || null == apikey || '' == apikey) {
+    vs.delprop(headers, HEADER_auth);
+  } else {
+    // A raw credential (empty prefix, e.g. an apiKey scheme) must go in
+    // as-is; only a non-empty prefix (Bearer/Basic/OAuth) is space-joined.
+    vs.setprop(
+        headers,
+        HEADER_auth,
+        (null != prefix && '' != prefix)
+            ? prefix.toString() + ' ' + apikey.toString()
+            : apikey);
+  }
+
+  return spec;
+}

package/project/.sdk/tm/dart/lib/utility/PrepareBodyUtility.dart

@@ -0,0 +1,19 @@
+dynamic prepareBody(dynamic ctx) {
+  final op = ctx.op;
+
+  final utility = ctx.utility;
+  final error = utility.makeError;
+  final transformRequest = utility.transformRequest;
+
+  dynamic body;
+
+  if ('data' == op.input) {
+    try {
+      body = transformRequest(ctx);
+    } catch (err) {
+      return error(ctx, err);
+    }
+  }
+
+  return body;
+}

package/project/.sdk/tm/dart/lib/utility/PrepareHeadersUtility.dart

@@ -0,0 +1,11 @@
+import 'voxgig_struct.dart' as vs;
+
+dynamic prepareHeaders(dynamic ctx) {
+  final client = ctx.client;
+
+  final options = client.options();
+
+  final out = vs.clone(vs.getprop(options, 'headers', {}));
+
+  return out;
+}

package/project/.sdk/tm/dart/lib/utility/PrepareMethodUtility.dart

@@ -0,0 +1,15 @@
+dynamic prepareMethod(dynamic ctx) {
+  final op = ctx.op;
+  final opname = op.name;
+
+  final methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'load': 'GET',
+    'list': 'GET',
+    'remove': 'DELETE',
+    'patch': 'PATCH',
+  };
+
+  return methodMap[opname];
+}

package/project/.sdk/tm/dart/lib/utility/PrepareParamsUtility.dart

@@ -0,0 +1,23 @@
+import 'voxgig_struct.dart' as vs;
+
+dynamic prepareParams(dynamic ctx) {
+  final utility = ctx.utility;
+  final findparam = utility.param;
+
+  final point = ctx.point;
+
+  final params = vs.getprop(point.args, 'params') ?? [];
+
+  final out = <String, dynamic>{};
+  for (final pd in params) {
+    final val = findparam(ctx, pd);
+    if (null != val) {
+      out[vs.getprop(pd, 'name').toString()] = val;
+    }
+  }
+
+  // TODO: review
+  // out = validate(out, point.validate.params)
+
+  return out;
+}

package/project/.sdk/tm/dart/lib/utility/PreparePathUtility.dart

@@ -0,0 +1,9 @@
+import 'voxgig_struct.dart' as vs;
+
+dynamic preparePath(dynamic ctx) {
+  final point = ctx.point;
+
+  final path = vs.join(point.parts, '/', true);
+
+  return path;
+}

package/project/.sdk/tm/dart/lib/utility/PrepareQueryUtility.dart

@@ -0,0 +1,18 @@
+import 'voxgig_struct.dart' as vs;
+
+dynamic prepareQuery(dynamic ctx) {
+  final point = ctx.point;
+  final params = point.params ?? [];
+  final reqmatch = ctx.reqmatch ?? {};
+
+  final out = <String, dynamic>{};
+  for (final item in vs.items(reqmatch)) {
+    final key = item[0];
+    final val = item[1];
+    if (null != val && !(params as List).contains(key)) {
+      out[key] = val;
+    }
+  }
+
+  return out;
+}

package/project/.sdk/tm/dart/lib/utility/ResultBasicUtility.dart

@@ -0,0 +1,29 @@
+import 'ErrUtility.dart';
+
+dynamic resultBasic(dynamic ctx) {
+  final response = ctx.response;
+  final result = ctx.result;
+
+  if (null != result && null != response) {
+    result.status = response.status ?? -1;
+    result.statusText = response.statusText ?? 'no-status';
+
+    // TODO: use spec!
+    if (result.status is num && 400 <= result.status) {
+      final msg = 'request: ' +
+          result.status.toString() +
+          ': ' +
+          result.statusText.toString();
+      if (null != result.err) {
+        final prevmsg = errmsg(result.err);
+        result.err = ctx.error('request_status', prevmsg + ': ' + msg);
+      } else {
+        result.err = ctx.error('request_status', msg);
+      }
+    } else if (null != response.err) {
+      result.err = response.err;
+    }
+  }
+
+  return result;
+}

package/project/.sdk/tm/dart/lib/utility/ResultBodyUtility.dart

@@ -0,0 +1,15 @@
+import 'dart:async';
+
+Future<dynamic> resultBody(dynamic ctx) async {
+  final response = ctx.response;
+  final result = ctx.result;
+
+  if (null != result) {
+    if (null != response && null != response.jsonFn && null != response.body) {
+      final json = await response.json();
+      result.body = json;
+    }
+  }
+
+  return result;
+}

package/project/.sdk/tm/dart/lib/utility/ResultHeadersUtility.dart

@@ -0,0 +1,18 @@
+dynamic resultHeaders(dynamic ctx) {
+  final response = ctx.response;
+  final result = ctx.result;
+
+  if (null != result) {
+    if (null != response && response.headers is Map) {
+      final headers = <String, dynamic>{};
+      (response.headers as Map).forEach((k, v) {
+        headers[k.toString()] = v;
+      });
+      result.headers = headers;
+    } else {
+      result.headers = <String, dynamic>{};
+    }
+  }
+
+  return result;
+}

package/project/.sdk/tm/dart/lib/utility/StructUtility.dart

@@ -0,0 +1,127 @@
+// Struct utility surface for the ProjectName SDK.
+//
+// Wraps the vendored voxgig struct port (voxgig_struct.dart) as an instance
+// whose members mirror the donor (ts) StructUtility class shape. Function
+// values are plain fields so tests and custom code can pass them around;
+// `byName` supports the string-keyed lookup the corpus test runner needs.
+
+import 'voxgig_struct.dart' as vs;
+
+export 'voxgig_struct.dart' show StructError;
+
+class StructUtility {
+  final clone = vs.clone;
+  final delprop = vs.delprop;
+  final escre = vs.escre;
+  final escurl = vs.escurl;
+  final filter = vs.filter;
+  final flatten = vs.flatten;
+  final getdef = vs.getdef;
+  final getelem = vs.getelem;
+  final getpath = vs.getpath;
+  final getprop = vs.getprop;
+  final haskey = vs.haskey;
+  final inject = vs.inject;
+  final isempty = vs.isempty;
+  final isfunc = vs.isfunc;
+  final iskey = vs.iskey;
+  final islist = vs.islist;
+  final ismap = vs.ismap;
+  final isnode = vs.isnode;
+  final items = vs.items;
+  final join = vs.join;
+  final joinurl = vs.joinurl;
+  final jsonify = vs.jsonify;
+  final keysof = vs.keysof;
+  final merge = vs.merge;
+  final pad = vs.pad;
+  final pathify = vs.pathify;
+  final select = vs.select;
+  final setpath = vs.setpath;
+  final setprop = vs.setprop;
+  final size = vs.size;
+  final strkey = vs.strkey;
+  final stringify = vs.stringify;
+  final transform = vs.transform;
+  final typify = vs.typify;
+  final typename = vs.typename;
+  final validate = vs.validate;
+
+  // The donor walk takes the apply functions positionally (before, after).
+  final walk = _walk;
+
+  // slice has an optional mutate flag in the port; expose donor arity.
+  final slice = _slice;
+
+  final SKIP = vs.SKIP;
+  final DELETE = vs.DELETE;
+
+  final T_any = vs.T_any;
+  final T_noval = vs.T_noval;
+  final T_boolean = vs.T_boolean;
+  final T_decimal = vs.T_decimal;
+  final T_integer = vs.T_integer;
+  final T_number = vs.T_number;
+  final T_string = vs.T_string;
+  final T_function = vs.T_function;
+  // The dart struct port has no symbol type; keep the donor bit slot.
+  final T_symbol = 1 << 23;
+  final T_null = vs.T_null;
+  final T_list = vs.T_list;
+  final T_map = vs.T_map;
+  final T_instance = vs.T_instance;
+  final T_scalar = vs.T_scalar;
+  final T_node = vs.T_node;
+
+  // String-keyed lookup for the corpus test runner (Dart has no dynamic
+  // property access, so subjects are resolved through this map).
+  dynamic byName(String name) => _byname[name];
+
+  late final Map<String, dynamic> _byname = {
+    'clone': clone,
+    'delprop': delprop,
+    'escre': escre,
+    'escurl': escurl,
+    'filter': filter,
+    'flatten': flatten,
+    'getdef': getdef,
+    'getelem': getelem,
+    'getpath': getpath,
+    'getprop': getprop,
+    'haskey': haskey,
+    'inject': inject,
+    'isempty': isempty,
+    'isfunc': isfunc,
+    'iskey': iskey,
+    'islist': islist,
+    'ismap': ismap,
+    'isnode': isnode,
+    'items': items,
+    'join': join,
+    'joinurl': joinurl,
+    'jsonify': jsonify,
+    'keysof': keysof,
+    'merge': merge,
+    'pad': pad,
+    'pathify': pathify,
+    'select': select,
+    'setpath': setpath,
+    'setprop': setprop,
+    'size': size,
+    'slice': slice,
+    'strkey': strkey,
+    'stringify': stringify,
+    'transform': transform,
+    'typify': typify,
+    'typename': typename,
+    'validate': validate,
+    'walk': walk,
+  };
+}
+
+dynamic _walk(dynamic val,
+        [Function? before, Function? after, dynamic maxdepth]) =>
+    vs.walk(val, before: before, after: after, maxdepth: maxdepth);
+
+dynamic _slice(dynamic val, [dynamic start, dynamic end]) =>
+    vs.slice(val, start, end);