@voxgig/sdkgen 0.35.2 → 0.36.0

package/project/.sdk/tm/php/feature/TestFeature.php

@@ -0,0 +1,193 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK test feature
+
+require_once __DIR__ . '/BaseFeature.php';
+
+class ProjectNameTestFeature extends ProjectNameBaseFeature
+{
+    private mixed $client;
+    private ?array $options;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->version = '0.0.1';
+        $this->name = 'test';
+        $this->active = true;
+        $this->client = null;
+        $this->options = null;
+    }
+
+    public function init(ProjectNameContext $ctx, array $options): void
+    {
+        $this->client = $ctx->client;
+        $this->options = $options;
+
+        $entity = \Voxgig\Struct\Struct::getprop($options, 'entity');
+        if (!is_array($entity)) {
+            $entity = [];
+        }
+
+        $this->client->mode = 'test';
+
+        // Ensure entity ids are correct.
+        \Voxgig\Struct\Struct::walk($entity, function ($key, $val, $parent, $path) {
+            if (count($path) === 2 && is_array($val) && $key !== null) {
+                $val['id'] = $key;
+            }
+            return $val;
+        });
+
+        $test_self = $this;
+
+        $test_fetcher = function (ProjectNameContext $fctx, string $_fullurl, array $_fetchdef) use ($entity, $test_self): array {
+            $respond = function (int $status, mixed $data, ?array $extra): array {
+                $out = [
+                    'status' => $status,
+                    'statusText' => 'OK',
+                    'json' => function () use ($data) { return $data; },
+                    'body' => 'not-used',
+                ];
+                if ($extra) {
+                    foreach ($extra as $k => $v) {
+                        $out[$k] = $v;
+                    }
+                }
+                return [$out, null];
+            };
+
+            $op = $fctx->op;
+            $entmap = \Voxgig\Struct\Struct::getprop($entity, $op->entity);
+            if (!is_array($entmap)) {
+                $entmap = [];
+            }
+
+            if ($op->name === 'load') {
+                $args = $test_self->build_args($fctx, $op, $fctx->reqmatch);
+                $found = \Voxgig\Struct\Struct::select($entmap, $args);
+                $ent = \Voxgig\Struct\Struct::getelem($found, 0);
+                if (!$ent) {
+                    return $respond(404, null, ['statusText' => 'Not found']);
+                }
+                \Voxgig\Struct\Struct::delprop($ent, '$KEY');
+                $out = \Voxgig\Struct\Struct::clone($ent);
+                return $respond(200, $out, null);
+
+            } elseif ($op->name === 'list') {
+                $args = $test_self->build_args($fctx, $op, $fctx->reqmatch);
+                $found = \Voxgig\Struct\Struct::select($entmap, $args);
+                if (!$found) {
+                    return $respond(404, null, ['statusText' => 'Not found']);
+                }
+                if (is_array($found)) {
+                    foreach ($found as $item) {
+                        \Voxgig\Struct\Struct::delprop($item, '$KEY');
+                    }
+                }
+                $out = \Voxgig\Struct\Struct::clone($found);
+                return $respond(200, $out, null);
+
+            } elseif ($op->name === 'update') {
+                $args = $test_self->build_args($fctx, $op, $fctx->reqdata);
+                $found = \Voxgig\Struct\Struct::select($entmap, $args);
+                $ent = \Voxgig\Struct\Struct::getelem($found, 0);
+                if (!$ent) {
+                    return $respond(404, null, ['statusText' => 'Not found']);
+                }
+                if (is_array($ent) && $fctx->reqdata) {
+                    foreach ($fctx->reqdata as $k => $v) {
+                        $ent[$k] = $v;
+                    }
+                }
+                \Voxgig\Struct\Struct::delprop($ent, '$KEY');
+                $out = \Voxgig\Struct\Struct::clone($ent);
+                return $respond(200, $out, null);
+
+            } elseif ($op->name === 'remove') {
+                $args = $test_self->build_args($fctx, $op, $fctx->reqmatch);
+                $found = \Voxgig\Struct\Struct::select($entmap, $args);
+                $ent = \Voxgig\Struct\Struct::getelem($found, 0);
+                if (!$ent) {
+                    return $respond(404, null, ['statusText' => 'Not found']);
+                }
+                if (is_array($ent)) {
+                    $id = \Voxgig\Struct\Struct::getprop($ent, 'id');
+                    \Voxgig\Struct\Struct::delprop($entmap, $id);
+                }
+                return $respond(200, null, null);
+
+            } elseif ($op->name === 'create') {
+                $test_self->build_args($fctx, $op, $fctx->reqdata);
+                $id = ($fctx->utility->param)($fctx, 'id');
+                if ($id === null) {
+                    $id = sprintf('%04x%04x%04x%04x', random_int(0, 0xFFFF), random_int(0, 0xFFFF), random_int(0, 0xFFFF), random_int(0, 0xFFFF));
+                }
+
+                $ent = \Voxgig\Struct\Struct::clone($fctx->reqdata);
+                if (is_array($ent)) {
+                    $ent['id'] = $id;
+                    if (is_string($id)) {
+                        $entmap[$id] = $ent;
+                    }
+                    \Voxgig\Struct\Struct::delprop($ent, '$KEY');
+                    $out = \Voxgig\Struct\Struct::clone($ent);
+                    return $respond(200, $out, null);
+                }
+                return $respond(200, $ent, null);
+
+            } else {
+                return $respond(404, null, ['statusText' => 'Unknown operation']);
+            }
+        };
+
+        $ctx->utility->fetcher = $test_fetcher;
+    }
+
+    public function build_args(ProjectNameContext $ctx, ProjectNameOperation $op, mixed $args): array
+    {
+        $opname = $op->name;
+        $entname = (is_object($ctx->entity) && method_exists($ctx->entity, 'get_name'))
+            ? $ctx->entity->get_name()
+            : '_';
+        $points = \Voxgig\Struct\Struct::getpath($ctx->config, "entity.{$entname}.op.{$opname}.points");
+        $point = \Voxgig\Struct\Struct::getelem($points, -1);
+
+        $params_path = \Voxgig\Struct\Struct::getpath($point, 'args.params');
+        $reqd_params = \Voxgig\Struct\Struct::select($params_path, ['reqd' => true]);
+        $reqd = \Voxgig\Struct\Struct::transform($reqd_params, ['`$EACH`', '', '`$KEY.name`']);
+
+        $qand = [];
+        $q = ['`$AND`' => &$qand];
+
+        if ($args) {
+            $keys = \Voxgig\Struct\Struct::keysof($args);
+            if ($keys) {
+                foreach ($keys as $key) {
+                    $is_id = ($key === 'id');
+                    $selected = \Voxgig\Struct\Struct::select($reqd, $key);
+                    $is_reqd = !\Voxgig\Struct\Struct::isempty($selected);
+
+                    if ($is_id || $is_reqd) {
+                        $v = ($ctx->utility->param)($ctx, $key);
+                        $ka = $op->alias_map ? \Voxgig\Struct\Struct::getprop($op->alias_map, $key) : null;
+
+                        $qor = [[$key => $v]];
+                        if (is_string($ka)) {
+                            $qor[] = [$ka => $v];
+                        }
+
+                        $qand[] = ['`$OR`' => $qor];
+                    }
+                }
+            }
+        }
+
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain['test'] = ['query' => $q];
+        }
+
+        return $q;
+    }
+}

package/project/.sdk/tm/php/src/feature/README.md

@@ -0,0 +1,3 @@
+# Features
+
+This folder contains the feature source templates.

package/project/.sdk/tm/php/test/Runner.php

@@ -0,0 +1,89 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK test runner
+
+class ProjectNameTestRunner
+{
+    private static array $env = [];
+
+    public static function load_env_local(): void
+    {
+        $env_file = __DIR__ . '/../../.env.local';
+        if (!file_exists($env_file)) {
+            return;
+        }
+
+        $lines = file($env_file, FILE_IGNORE_NEW_LINES);
+        if ($lines === false) {
+            return;
+        }
+
+        foreach ($lines as $line) {
+            $line = trim($line);
+            if ($line === '' || str_starts_with($line, '#')) {
+                continue;
+            }
+            $parts = explode('=', $line, 2);
+            if (count($parts) !== 2) {
+                continue;
+            }
+            self::$env[trim($parts[0])] = trim($parts[1]);
+        }
+    }
+
+    public static function getenv(string $key): ?string
+    {
+        if (isset(self::$env[$key])) {
+            return self::$env[$key];
+        }
+        $val = \getenv($key);
+        return $val !== false ? $val : null;
+    }
+
+    public static function env_override(array &$m): array
+    {
+        $live = self::getenv('PROJECTNAME_TEST_LIVE');
+        $override = self::getenv('PROJECTNAME_TEST_OVERRIDE');
+
+        if ($live === 'TRUE' || $override === 'TRUE') {
+            foreach (array_keys($m) as $key) {
+                $envval = self::getenv($key);
+                if ($envval !== null && $envval !== '') {
+                    $envval = trim($envval);
+                    if (str_starts_with($envval, '{')) {
+                        $parsed = json_decode($envval, true);
+                        if (json_last_error() === JSON_ERROR_NONE) {
+                            $m[$key] = $parsed;
+                            continue;
+                        }
+                    }
+                    $m[$key] = $envval;
+                }
+            }
+        }
+
+        $explain = self::getenv('PROJECTNAME_TEST_EXPLAIN');
+        if ($explain !== null && $explain !== '') {
+            $m['PROJECTNAME_TEST_EXPLAIN'] = $explain;
+        }
+
+        return $m;
+    }
+
+    public static function entity_list_to_data(array $list): array
+    {
+        $out = [];
+        foreach ($list as $item) {
+            if (is_array($item)) {
+                $out[] = $item;
+            } elseif (is_object($item) && method_exists($item, 'data_get')) {
+                $d = $item->data_get();
+                if (is_array($d)) {
+                    $out[] = $d;
+                }
+            }
+        }
+        return $out;
+    }
+}

package/project/.sdk/tm/php/utility/Clean.php

@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: clean
+
+class ProjectNameClean
+{
+    public static function call(ProjectNameContext $ctx, mixed $val): mixed
+    {
+        return $val;
+    }
+}

package/project/.sdk/tm/php/utility/Done.php

@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: done
+
+class ProjectNameDone
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain = ($ctx->utility->clean)($ctx, $ctx->ctrl->explain);
+            $er = $ctx->ctrl->explain['result'] ?? null;
+            if (is_array($er)) {
+                unset($ctx->ctrl->explain['result']['err']);
+            }
+        }
+        if ($ctx->result && $ctx->result->ok) {
+            $resdata = $ctx->result->resdata;
+            if (is_object($resdata)) {
+                $resdata = (array)$resdata;
+            }
+            return [$resdata, null];
+        }
+        return ($ctx->utility->make_error)($ctx, null);
+    }
+}

package/project/.sdk/tm/php/utility/FeatureAdd.php

@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: feature_add
+
+class ProjectNameFeatureAdd
+{
+    public static function call(ProjectNameContext $ctx, mixed $f): void
+    {
+        $ctx->client->features[] = $f;
+    }
+}

package/project/.sdk/tm/php/utility/FeatureHook.php

@@ -0,0 +1,23 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: feature_hook
+
+class ProjectNameFeatureHook
+{
+    public static function call(ProjectNameContext $ctx, string $name): void
+    {
+        if (!$ctx->client) {
+            return;
+        }
+        $features = $ctx->client->features ?? null;
+        if (!$features) {
+            return;
+        }
+        foreach ($features as $f) {
+            if (method_exists($f, $name)) {
+                $f->$name($ctx);
+            }
+        }
+    }
+}

package/project/.sdk/tm/php/utility/FeatureInit.php

@@ -0,0 +1,25 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: feature_init
+
+class ProjectNameFeatureInit
+{
+    public static function call(ProjectNameContext $ctx, mixed $f): void
+    {
+        $fname = $f->get_name();
+        $fopts = [];
+        if ($ctx->options) {
+            $feature_opts = \Voxgig\Struct\Struct::getprop($ctx->options, 'feature');
+            if (is_array($feature_opts)) {
+                $fo = \Voxgig\Struct\Struct::getprop($feature_opts, $fname);
+                if (is_array($fo)) {
+                    $fopts = $fo;
+                }
+            }
+        }
+        if (($fopts['active'] ?? null) === true) {
+            $f->init($ctx, $fopts);
+        }
+    }
+}

package/project/.sdk/tm/php/utility/Fetcher.php

@@ -0,0 +1,101 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: fetcher
+
+class ProjectNameFetcher
+{
+    public static function defaultHttpFetch(string $fullurl, array $fetchdef): array
+    {
+        $method_str = $fetchdef['method'] ?? 'GET';
+        $body_str = $fetchdef['body'] ?? null;
+        $headers = $fetchdef['headers'] ?? [];
+
+        $opts = [
+            'http' => [
+                'method' => strtoupper($method_str),
+                'ignore_errors' => true,
+            ],
+        ];
+
+        $header_lines = [];
+        foreach ($headers as $k => $v) {
+            if (is_string($v)) {
+                $header_lines[] = "{$k}: {$v}";
+            }
+        }
+
+        if (is_string($body_str)) {
+            $opts['http']['content'] = $body_str;
+        }
+
+        if (!empty($header_lines)) {
+            $opts['http']['header'] = implode("\r\n", $header_lines);
+        }
+
+        $context = stream_context_create($opts);
+        $response_body = @file_get_contents($fullurl, false, $context);
+
+        $status = 0;
+        $status_text = '';
+        $resp_headers = [];
+
+        if (isset($http_response_header) && is_array($http_response_header)) {
+            foreach ($http_response_header as $header) {
+                if (preg_match('/^HTTP\/\S+\s+(\d+)\s+(.*)$/i', $header, $matches)) {
+                    $status = (int)$matches[1];
+                    $status_text = trim($matches[2]);
+                } else {
+                    $parts = explode(':', $header, 2);
+                    if (count($parts) === 2) {
+                        $resp_headers[strtolower(trim($parts[0]))] = trim($parts[1]);
+                    }
+                }
+            }
+        }
+
+        $json_body = null;
+        if ($response_body !== false && $response_body !== '') {
+            $decoded = json_decode($response_body, true);
+            if (json_last_error() === JSON_ERROR_NONE) {
+                $json_body = $decoded;
+            }
+        }
+
+        return [
+            [
+                'status' => $status,
+                'statusText' => $status_text,
+                'headers' => $resp_headers,
+                'json' => function () use ($json_body) { return $json_body; },
+                'body' => $response_body !== false ? $response_body : '',
+            ],
+            null,
+        ];
+    }
+
+    public static function call(ProjectNameContext $ctx, string $fullurl, array $fetchdef): array
+    {
+        if ($ctx->client->mode !== 'live') {
+            return [null, $ctx->make_error('fetch_mode_block',
+                "Request blocked by mode: \"{$ctx->client->mode}\" (URL was: \"{$fullurl}\")")];
+        }
+
+        $options = $ctx->client->options_map();
+        if (\Voxgig\Struct\Struct::getpath($options, 'feature.test.active') === true) {
+            return [null, $ctx->make_error('fetch_test_block',
+                "Request blocked as test feature is active (URL was: \"{$fullurl}\")")];
+        }
+
+        $sys_fetch = \Voxgig\Struct\Struct::getpath($options, 'system.fetch');
+
+        if ($sys_fetch === null) {
+            return self::defaultHttpFetch($fullurl, $fetchdef);
+        }
+        if (is_callable($sys_fetch)) {
+            return $sys_fetch($fullurl, $fetchdef);
+        }
+
+        return [null, $ctx->make_error('fetch_invalid', 'system.fetch is not a valid function')];
+    }
+}

package/project/.sdk/tm/php/utility/MakeContext.php

@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_context
+
+require_once __DIR__ . '/../core/Context.php';
+
+class ProjectNameMakeContext
+{
+    public static function call(array $ctxmap, ?ProjectNameContext $basectx): ProjectNameContext
+    {
+        return new ProjectNameContext($ctxmap, $basectx);
+    }
+}

package/project/.sdk/tm/php/utility/MakeError.php

@@ -0,0 +1,59 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_error
+
+require_once __DIR__ . '/../core/Operation.php';
+require_once __DIR__ . '/../core/Result.php';
+require_once __DIR__ . '/../core/Error.php';
+
+class ProjectNameMakeError
+{
+    public static function call(?ProjectNameContext $ctx, mixed $err): array
+    {
+        if ($ctx === null) {
+            require_once __DIR__ . '/../core/Context.php';
+            $ctx = new ProjectNameContext([], null);
+        }
+        $op = $ctx->op ?? new ProjectNameOperation([]);
+        $opname = $op->name;
+        if ($opname === '' || $opname === '_') {
+            $opname = 'unknown operation';
+        }
+
+        $result = $ctx->result ?? new ProjectNameResult([]);
+        $result->ok = false;
+
+        if ($err === null) {
+            $err = $result->err;
+        }
+        if ($err === null) {
+            $err = $ctx->make_error('unknown', 'unknown error');
+        }
+
+        $errmsg = ($err instanceof ProjectNameError) ? $err->msg : (string)$err;
+        $msg = "ProjectNameSDK: {$opname}: {$errmsg}";
+        $msg = ($ctx->utility->clean)($ctx, $msg);
+
+        $result->err = null;
+        $spec = $ctx->spec;
+
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain['err'] = ['message' => $msg];
+        }
+
+        $sdk_err = new ProjectNameError('', $msg, $ctx);
+        $sdk_err->result = ($ctx->utility->clean)($ctx, $result);
+        $sdk_err->spec = ($ctx->utility->clean)($ctx, $spec);
+        if ($err instanceof ProjectNameError) {
+            $sdk_err->sdk_code = $err->sdk_code;
+        }
+
+        $ctx->ctrl->err = $sdk_err;
+
+        if ($ctx->ctrl->throw_err === false) {
+            return [$result->resdata, null];
+        }
+        return [null, $sdk_err];
+    }
+}

package/project/.sdk/tm/php/utility/MakeFetchDef.php

@@ -0,0 +1,36 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_fetch_def
+
+require_once __DIR__ . '/../core/Result.php';
+
+class ProjectNameMakeFetchDef
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        $spec = $ctx->spec;
+        if (!$spec) {
+            return [null, $ctx->make_error('fetchdef_no_spec', 'Expected context spec property to be defined.')];
+        }
+
+        if (!$ctx->result) {
+            $ctx->result = new ProjectNameResult([]);
+        }
+        $spec->step = 'prepare';
+
+        [$url, $err] = ($ctx->utility->make_url)($ctx);
+        if ($err) {
+            return [null, $err];
+        }
+
+        $spec->url = $url;
+
+        $fetchdef = ['url' => $url, 'method' => $spec->method, 'headers' => $spec->headers];
+        if ($spec->body !== null) {
+            $fetchdef['body'] = is_array($spec->body) ? \Voxgig\Struct\Struct::jsonify($spec->body) : $spec->body;
+        }
+
+        return [$fetchdef, null];
+    }
+}