@voxgig/sdkgen 1.3.7 → 1.3.9

package/project/.sdk/tm/dart/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ Voxgig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/dart/Makefile

@@ -0,0 +1,50 @@
+.PHONY: test build lint clean publish
+
+# Run the full generated test suite (dependency-free plain runner).
+test:
+	dart run test/main.dart
+
+# "Lint": static analysis (a clean `dart analyze` means the code is sound).
+lint:
+	dart analyze
+
+# Build smoke-test: compile the SDK entry to a kernel snapshot.
+build:
+	dart analyze lib
+
+clean:
+	rm -rf .dart_tool *.dill
+
+# --- Release: publish to pub.dev -------------------------------------------
+# Publish this package to pub.dev, then tag dart/vX.Y.Z. pub.dev uses OAuth —
+# headless, the vault supplies the credentials JSON as PUB_CREDENTIALS and we
+# write it to the dart config path before publishing; the github token pushes
+# the tag. set -e + tag-last: a failed upload never leaves a tag behind.
+VERSION := $(shell sed -nE 's/^version: *([0-9][^ ]*).*/\1/p' pubspec.yaml | head -1)
+TAG := dart/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish: test
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists — bump pubspec.yaml version first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: would publish to pub.dev and tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	if [ -n "$$PUB_CREDENTIALS" ]; then \
+	  creddir="$$HOME/Library/Application Support/dart"; \
+	  [ -d "$$HOME/Library/Application Support" ] || creddir="$${XDG_CONFIG_HOME:-$$HOME/.config}/dart"; \
+	  mkdir -p "$$creddir"; \
+	  printf '%s' "$$PUB_CREDENTIALS" > "$$creddir/pub-credentials.json"; \
+	fi; \
+	dart pub publish --force; \
+	git tag -a "$(TAG)" -m "dart v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Published to pub.dev + tag $(TAG)."

package/project/.sdk/tm/dart/lib/Context.dart

@@ -0,0 +1,150 @@
+import 'dart:math';
+
+import 'ProjectNameError.dart';
+
+import 'utility/voxgig_struct.dart' as vs;
+
+import 'Operation.dart';
+import 'Point.dart';
+import 'Response.dart';
+import 'Result.dart';
+import 'Spec.dart';
+
+class Context {
+  String id = 'C' +
+      (Random().nextInt(0x3fffffff) + 0x40000000).toString().substring(0, 8);
+
+  // Store the output of each operation step.
+  Map<String, dynamic> out = {};
+
+  // Per-operation control settings (plain map: throw, explain, actor, ...).
+  dynamic ctrl = {};
+  dynamic meta = {};
+
+  dynamic client;
+  dynamic utility;
+
+  dynamic op;
+  dynamic point;
+
+  dynamic config;
+  dynamic entopts;
+  dynamic options;
+
+  dynamic opmap;
+
+  dynamic response;
+  dynamic result;
+  dynamic spec;
+
+  dynamic data;
+  dynamic reqdata;
+  dynamic match;
+  dynamic reqmatch;
+
+  dynamic entity;
+
+  // Shared persistent store.
+  dynamic shared;
+
+  Context(dynamic ctxmap, [dynamic basectx]) {
+    client = vs.getprop(ctxmap, 'client') ?? basectx?.client;
+    utility = vs.getprop(ctxmap, 'utility') ?? basectx?.utility;
+
+    final rawctrl = vs.getprop(ctxmap, 'ctrl');
+    ctrl = null != rawctrl
+        ? (rawctrl is Map && rawctrl is! Map<String, dynamic>
+            ? Map<String, dynamic>.from(rawctrl)
+            : rawctrl)
+        : (basectx?.ctrl ?? {});
+    meta = vs.getprop(ctxmap, 'meta') ?? basectx?.meta ?? {};
+
+    config = vs.getprop(ctxmap, 'config') ?? basectx?.config;
+    entopts = vs.getprop(ctxmap, 'entopts') ?? basectx?.entopts;
+    options = vs.getprop(ctxmap, 'options') ?? basectx?.options;
+
+    entity = vs.getprop(ctxmap, 'entity') ?? basectx?.entity;
+    shared = vs.getprop(ctxmap, 'shared') ?? basectx?.shared;
+    opmap = vs.getprop(ctxmap, 'opmap') ?? basectx?.opmap ?? {};
+
+    data = vs.getprop(ctxmap, 'data', {});
+    reqdata = vs.getprop(ctxmap, 'reqdata', {});
+    match = vs.getprop(ctxmap, 'match', {});
+    reqmatch = vs.getprop(ctxmap, 'reqmatch', {});
+
+    point = _aspoint(vs.getprop(ctxmap, 'point')) ?? basectx?.point;
+    spec = _asspec(vs.getprop(ctxmap, 'spec')) ?? basectx?.spec;
+    result = _asresult(vs.getprop(ctxmap, 'result')) ?? basectx?.result;
+    response = _asresponse(vs.getprop(ctxmap, 'response')) ?? basectx?.response;
+
+    final opname = vs.getprop(ctxmap, 'opname');
+    op = resolveOp(opname);
+  }
+
+  // JSON-sourced context maps carry plain maps for the pipeline value
+  // classes; coerce them so utilities can use typed member access.
+  dynamic _aspoint(dynamic v) => v is Map ? Point(v) : v;
+  dynamic _asspec(dynamic v) => v is Map ? Spec(v) : v;
+  dynamic _asresult(dynamic v) => v is Map ? Result(v) : v;
+  dynamic _asresponse(dynamic v) => v is Map ? Response(v) : v;
+
+  dynamic resolveOp(dynamic opname) {
+    // Cache key is `<entity>:<opname>` so two entities with the same op
+    // (e.g. both have a "list") get distinct cached Operations. Keying on
+    // opname alone caused the first-resolved entity's points to be served
+    // to every subsequent entity's call.
+    var entname = '';
+    final ent = entity;
+    if (null != ent) {
+      if (ent is Map) {
+        entname = vs.getprop(ent, 'name', '') ?? '';
+      } else {
+        try {
+          entname = (ent.name ?? '') as String;
+        } catch (_e) {
+          entname = '';
+        }
+      }
+    }
+
+    final cacheKey = entname + ':' + ('' + (opname ?? '').toString());
+    dynamic op = vs.getprop(opmap, cacheKey);
+
+    if (null == op && null != opname) {
+      final opcfg = vs.getpath(config, ['entity', entname, 'op', opname]);
+      var input = 'match';
+
+      if ('update' == opname || 'create' == opname) {
+        input = 'data';
+      }
+
+      op = Operation({
+        'entity': entname,
+        'name': opname,
+        'input': input,
+        'points': vs.getprop(opcfg, 'points', []),
+      });
+
+      vs.setprop(opmap, cacheKey, op);
+    }
+
+    return op;
+  }
+
+  ProjectNameError error(String code, String msg) {
+    return ProjectNameError(code, msg, this);
+  }
+
+  Map<String, dynamic> toJSON() => {
+        'id': id,
+        'op': op,
+        'spec': spec,
+        'entity': entity,
+        'result': result,
+        'response': response,
+        'meta': meta,
+      };
+
+  @override
+  String toString() => 'Context ' + id;
+}

package/project/.sdk/tm/dart/lib/Control.dart

@@ -0,0 +1,15 @@
+import 'utility/voxgig_struct.dart' as vs;
+
+// The operation pipeline passes ctrl as a plain map (see Context.ctrl);
+// this class documents the recognised control keys.
+class Control {
+  dynamic throwErr;
+  dynamic err;
+  dynamic explain;
+
+  Control(dynamic ctrlmap) {
+    throwErr = vs.getprop(ctrlmap, 'throw');
+    err = vs.getprop(ctrlmap, 'err');
+    explain = vs.getprop(ctrlmap, 'explain');
+  }
+}

package/project/.sdk/tm/dart/lib/Operation.dart

@@ -0,0 +1,31 @@
+import 'utility/voxgig_struct.dart' as vs;
+
+import 'Point.dart';
+
+class Operation {
+  dynamic entity;
+  dynamic name;
+  dynamic input;
+  List<dynamic> points = [];
+
+  Operation(dynamic opmap) {
+    entity = vs.getprop(opmap, 'entity', '_');
+    name = vs.getprop(opmap, 'name', '_');
+    input = vs.getprop(opmap, 'input', '_');
+
+    final rawpoints = vs.getprop(opmap, 'points', []);
+    points = [];
+    if (rawpoints is List) {
+      for (final p in rawpoints) {
+        points.add(p is Point ? p : Point(p));
+      }
+    }
+  }
+
+  Map<String, dynamic> toJSON() => {
+        'entity': entity,
+        'name': name,
+        'input': input,
+        'points': points,
+      };
+}

package/project/.sdk/tm/dart/lib/Point.dart

@@ -0,0 +1,43 @@
+import 'utility/voxgig_struct.dart' as vs;
+
+class Point {
+  dynamic args;
+  dynamic rename;
+  dynamic method;
+  dynamic orig;
+  dynamic parts;
+  dynamic params;
+  dynamic select;
+  dynamic active;
+  dynamic relations;
+  dynamic alias;
+  dynamic transform;
+
+  Point(dynamic altmap) {
+    args = vs.getprop(altmap, 'args', {'params': []});
+    rename = vs.getprop(altmap, 'rename', {'params': {}});
+    method = vs.getprop(altmap, 'method', '');
+    orig = vs.getprop(altmap, 'orig', '');
+    parts = vs.getprop(altmap, 'parts', []);
+    params = vs.getprop(altmap, 'params', []);
+    select = vs.getprop(altmap, 'select');
+    active = vs.getprop(altmap, 'active', false);
+    relations = vs.getprop(altmap, 'relations', []);
+    alias = vs.getprop(altmap, 'alias', {});
+    transform = vs.getprop(altmap, 'transform', {'req': null, 'res': null});
+  }
+
+  Map<String, dynamic> toJSON() => {
+        'args': args,
+        'rename': rename,
+        'method': method,
+        'orig': orig,
+        'parts': parts,
+        'params': params,
+        'select': select,
+        'active': active,
+        'relations': relations,
+        'alias': alias,
+        'transform': transform,
+      };
+}

package/project/.sdk/tm/dart/lib/Response.dart

@@ -0,0 +1,32 @@
+import 'dart:async';
+
+import 'utility/voxgig_struct.dart' as vs;
+
+class Response {
+  dynamic status;
+  dynamic statusText;
+  dynamic headers;
+  dynamic jsonFn;
+  dynamic err;
+  dynamic body;
+
+  Response(dynamic resmap) {
+    status = vs.getprop(resmap, 'status', -1);
+    statusText = vs.getprop(resmap, 'statusText', '');
+    headers = vs.getprop(resmap, 'headers');
+    jsonFn = vs.getprop(resmap, 'json');
+    body = vs.getprop(resmap, 'body');
+    err = vs.getprop(resmap, 'err');
+  }
+
+  Future<dynamic> json() async =>
+      null == jsonFn ? null : await Future.value(jsonFn());
+
+  Map<String, dynamic> toJSON() => {
+        'status': status,
+        'statusText': statusText,
+        'headers': headers,
+        'body': body,
+        'err': err,
+      };
+}

package/project/.sdk/tm/dart/lib/Result.dart

@@ -0,0 +1,39 @@
+import 'utility/voxgig_struct.dart' as vs;
+
+class Result {
+  dynamic ok;
+  dynamic status;
+  dynamic statusText;
+  dynamic headers;
+  dynamic body;
+  dynamic err;
+  dynamic resdata;
+  dynamic resmatch;
+
+  // Feature extension slots (paging, streaming).
+  dynamic paging;
+  dynamic streaming;
+  dynamic stream;
+
+  Result(dynamic resmap) {
+    ok = vs.getprop(resmap, 'ok', false);
+    status = vs.getprop(resmap, 'status', -1);
+    statusText = vs.getprop(resmap, 'statusText', '');
+    headers = vs.getprop(resmap, 'headers', {});
+    body = vs.getprop(resmap, 'body');
+    err = vs.getprop(resmap, 'err');
+    resdata = vs.getprop(resmap, 'resdata');
+    resmatch = vs.getprop(resmap, 'resmatch');
+  }
+
+  Map<String, dynamic> toJSON() => {
+        'ok': ok,
+        'status': status,
+        'statusText': statusText,
+        'headers': headers,
+        'body': body,
+        'err': err,
+        'resdata': resdata,
+        'resmatch': resmatch,
+      };
+}

package/project/.sdk/tm/dart/lib/Spec.dart

@@ -0,0 +1,49 @@
+import 'utility/voxgig_struct.dart' as vs;
+
+class Spec {
+  dynamic parts;
+  dynamic headers;
+  dynamic alias;
+  dynamic base;
+  dynamic prefix;
+  dynamic suffix;
+  dynamic params;
+  dynamic query;
+  dynamic step;
+  dynamic method;
+  dynamic body;
+  dynamic url;
+  dynamic path;
+
+  Spec(dynamic specmap) {
+    parts = vs.getprop(specmap, 'parts', []);
+    headers = vs.getprop(specmap, 'headers', {});
+    alias = vs.getprop(specmap, 'alias', {});
+    base = vs.getprop(specmap, 'base', '');
+    prefix = vs.getprop(specmap, 'prefix', '');
+    suffix = vs.getprop(specmap, 'suffix', '');
+    params = vs.getprop(specmap, 'params', {});
+    query = vs.getprop(specmap, 'query', {});
+    step = vs.getprop(specmap, 'step', '');
+    method = vs.getprop(specmap, 'method', 'GET');
+    body = vs.getprop(specmap, 'body');
+    url = vs.getprop(specmap, 'url');
+    path = vs.getprop(specmap, 'path');
+  }
+
+  Map<String, dynamic> toJSON() => {
+        'parts': parts,
+        'headers': headers,
+        'alias': alias,
+        'base': base,
+        'prefix': prefix,
+        'suffix': suffix,
+        'params': params,
+        'query': query,
+        'step': step,
+        'method': method,
+        'body': body,
+        'url': url,
+        'path': path,
+      };
+}

package/project/.sdk/tm/dart/lib/feature/audit/AuditFeature.dart

@@ -0,0 +1,103 @@
+// ignore_for_file: non_constant_identifier_names
+
+import '../base/BaseFeature.dart';
+
+// Audit trail. Emits a structured record for every operation — who (actor),
+// what (entity + op), the outcome, and a correlation id — suitable for
+// compliance logging. Records accumulate on the client track
+// (`audit.records`, bounded by `max`) and, when a `sink` callback is
+// supplied, are also pushed to it (e.g. to forward to a SIEM). The actor is
+// taken from options (`actor`) or a per-call `ctrl.actor`. Timestamps use
+// the injectable `now` clock so tests stay deterministic.
+class AuditFeature extends BaseFeature {
+  dynamic _client;
+  int _seq = 0;
+  final Set<dynamic> _seen = {};
+
+  AuditFeature() {
+    version = '0.0.1';
+    name = 'audit';
+    active = true;
+  }
+
+  @override
+  dynamic init(dynamic ctx, dynamic opts) {
+    _client = ctx.client;
+    options = opts is Map ? Map<String, dynamic>.from(opts) : {};
+    active = true == options['active'];
+    _seq = 0;
+    _seen.clear();
+
+    final track = _client.track;
+    if (null == track['audit']) {
+      track['audit'] = <String, dynamic>{'records': <dynamic>[]};
+    }
+    return null;
+  }
+
+  @override
+  dynamic PreDone(dynamic ctx) {
+    // Outcome reflects the actual result; a non-2xx reaches PreDone before
+    // the pipeline throws.
+    _emit(
+        ctx,
+        (null != ctx.result &&
+                false != ctx.result.ok &&
+                null == ctx.result.err)
+            ? 'ok'
+            : 'error');
+    return null;
+  }
+
+  @override
+  dynamic PreUnexpected(dynamic ctx) {
+    _emit(ctx, 'error');
+    return null;
+  }
+
+  void _emit(dynamic ctx, String outcome) {
+    // One record per operation (PreDone + a following PreUnexpected on a
+    // non-2xx must not double-log).
+    if (_seen.contains(ctx)) {
+      return;
+    }
+    _seen.add(ctx);
+    _seq++;
+    final record = <String, dynamic>{
+      'seq': _seq,
+      'ts': _now(),
+      'actor': (ctx.ctrl is Map ? ctx.ctrl['actor'] : null) ??
+          options['actor'] ??
+          'anonymous',
+      'entity': null == ctx.op ? '_' : (ctx.op.entity ?? '_'),
+      'op': null == ctx.op ? '_' : (ctx.op.name ?? '_'),
+      'outcome': outcome,
+      'status': null == ctx.result ? null : ctx.result.status,
+      'correlationId': ctx.id,
+    };
+
+    final List recs = _client.track['audit']['records'];
+    recs.add(record);
+    final max = null == options['max'] ? 1000 : (options['max'] as num).toInt();
+    while (recs.length > max) {
+      recs.removeAt(0);
+    }
+
+    final sink = options['sink'];
+    if (sink is Function) {
+      try {
+        sink(record);
+      } catch (_e) {
+        // Sink failures are swallowed.
+      }
+    }
+  }
+
+  num _now() {
+    final now = options['now'];
+    if (now is Function) {
+      return now();
+    }
+    return DateTime.now().millisecondsSinceEpoch;
+  }
+}

package/project/.sdk/tm/dart/lib/feature/base/BaseFeature.dart

@@ -0,0 +1,76 @@
+// Base feature class implementing every pipeline hook as a no-op.
+// Features subclass this and override the hooks they need. Hook dispatch is
+// by name (see FeatureHookUtility), routed through `invokeHook` since Dart
+// has no dynamic property access.
+
+// ignore_for_file: non_constant_identifier_names
+
+class BaseFeature {
+  String version = '0.0.1';
+  String name = 'base';
+  bool active = true;
+
+  // Feature options as passed to init (used by featureAdd ordering).
+  Map<String, dynamic> options = {};
+
+  dynamic init(dynamic ctx, dynamic opts) {}
+
+  dynamic PostConstruct(dynamic ctx) {}
+
+  dynamic PostConstructEntity(dynamic ctx) {}
+
+  dynamic SetData(dynamic ctx) {}
+
+  dynamic GetData(dynamic ctx) {}
+
+  dynamic SetMatch(dynamic ctx) {}
+
+  dynamic GetMatch(dynamic ctx) {}
+
+  dynamic PrePoint(dynamic ctx) {}
+
+  dynamic PreSpec(dynamic ctx) {}
+
+  dynamic PreRequest(dynamic ctx) {}
+
+  dynamic PreResponse(dynamic ctx) {}
+
+  dynamic PreResult(dynamic ctx) {}
+
+  dynamic PreDone(dynamic ctx) {}
+
+  dynamic PreUnexpected(dynamic ctx) {}
+
+  dynamic invokeHook(String hook, dynamic ctx) {
+    switch (hook) {
+      case 'PostConstruct':
+        return PostConstruct(ctx);
+      case 'PostConstructEntity':
+        return PostConstructEntity(ctx);
+      case 'SetData':
+        return SetData(ctx);
+      case 'GetData':
+        return GetData(ctx);
+      case 'SetMatch':
+        return SetMatch(ctx);
+      case 'GetMatch':
+        return GetMatch(ctx);
+      case 'PrePoint':
+        return PrePoint(ctx);
+      case 'PreSpec':
+        return PreSpec(ctx);
+      case 'PreRequest':
+        return PreRequest(ctx);
+      case 'PreResponse':
+        return PreResponse(ctx);
+      case 'PreResult':
+        return PreResult(ctx);
+      case 'PreDone':
+        return PreDone(ctx);
+      case 'PreUnexpected':
+        return PreUnexpected(ctx);
+      default:
+        return null;
+    }
+  }
+}