@voxgig/sdkgen 0.35.2 → 0.37.0

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,105 @@
+<?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 = [];
+
+        $response_headers = function_exists('http_get_last_response_headers')
+            ? http_get_last_response_headers()
+            : ($http_response_header ?? []);
+
+        if (is_array($response_headers)) {
+            foreach ($response_headers 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];
+    }
+}

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

@@ -0,0 +1,102 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_options
+
+class ProjectNameMakeOptions
+{
+    private static function to_array_deep(mixed $val): mixed
+    {
+        if ($val instanceof \Closure) {
+            return $val;
+        }
+        if (is_object($val)) {
+            $val = (array)$val;
+        }
+        if (is_array($val)) {
+            foreach ($val as $k => $v) {
+                if (is_object($v) || is_array($v)) {
+                    $val[$k] = self::to_array_deep($v);
+                }
+            }
+        }
+        return $val;
+    }
+
+    public static function call(ProjectNameContext $ctx): array
+    {
+        $options = $ctx->options ?? [];
+
+        $custom_utils = \Voxgig\Struct\Struct::getprop($options, 'utility');
+        if ((is_array($custom_utils) || is_object($custom_utils)) && $ctx->utility) {
+            foreach ((array)$custom_utils as $k => $v) {
+                $ctx->utility->custom[$k] = $v;
+            }
+        }
+
+        // Preserve system.fetch before merge/validate.
+        $sys_fetch = \Voxgig\Struct\Struct::getpath($options, 'system.fetch');
+
+        $opts = \Voxgig\Struct\Struct::clone($options);
+        $opts = self::to_array_deep($opts);
+        if (!is_array($opts)) {
+            $opts = [];
+        }
+
+        $config = $ctx->config ?? [];
+        $cfgopts = isset($config['options']) && is_array($config['options']) ? $config['options'] : [];
+
+        $optspec = [
+            'apikey' => '',
+            'base' => 'http://localhost:8000',
+            'prefix' => '',
+            'suffix' => '',
+            'auth' => ['prefix' => ''],
+            'headers' => ['`$CHILD`' => '`$STRING`'],
+            'allow' => [
+                'method' => 'GET,PUT,POST,PATCH,DELETE,OPTIONS',
+                'op' => 'create,update,load,list,remove,command,direct',
+            ],
+            'entity' => ['`$CHILD`' => ['`$OPEN`' => true, 'active' => false, 'alias' => (object)[]]],
+            'feature' => ['`$CHILD`' => ['`$OPEN`' => true, 'active' => false]],
+            'utility' => (object)[],
+            'system' => (object)[],
+            'test' => ['active' => false, 'entity' => ['`$OPEN`' => true]],
+            'clean' => ['keys' => 'key,token,id'],
+        ];
+
+        // Empty [] would be treated as a list and clobber the map under merge;
+        // substitute an empty stdClass to preserve map semantics.
+        $cfgopts_merge = empty($cfgopts) ? new \stdClass() : $cfgopts;
+        $opts_merge = empty($opts) ? new \stdClass() : $opts;
+        $merged = \Voxgig\Struct\Struct::merge([(object)[], $cfgopts_merge, $opts_merge]);
+        $validated = \Voxgig\Struct\Struct::validate($merged, $optspec);
+        $opts = self::to_array_deep($validated);
+        if (!is_array($opts)) {
+            $opts = [];
+        }
+
+        if ($sys_fetch) {
+            if (!is_array($opts['system'] ?? null)) {
+                $opts['system'] = [];
+            }
+            $opts['system']['fetch'] = $sys_fetch;
+        }
+
+        $clean_keys = \Voxgig\Struct\Struct::getpath($opts, 'clean.keys');
+        if (!is_string($clean_keys)) {
+            $clean_keys = 'key,token,id';
+        }
+        $parts = array_filter(array_map('trim', explode(',', $clean_keys)), function ($p) {
+            return $p !== '';
+        });
+        $parts = array_map(function ($p) {
+            return \Voxgig\Struct\Struct::escre($p);
+        }, $parts);
+        $keyre = implode('|', $parts);
+        $derived = ['clean' => $keyre === '' ? [] : ['keyre' => $keyre]];
+        $opts['__derived__'] = $derived;
+
+        return $opts;
+    }
+}

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

@@ -0,0 +1,87 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_point
+
+require_once __DIR__ . '/../core/Helpers.php';
+
+class ProjectNameMakePoint
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        if (isset($ctx->out['point'])) {
+            $ctx->point = $ctx->out['point'];
+            return [$ctx->point, null];
+        }
+
+        $op = $ctx->op;
+        $options = $ctx->options;
+
+        $allow_op = \Voxgig\Struct\Struct::getpath($options, 'allow.op') ?? '';
+        if (strpos($allow_op, $op->name) === false) {
+            return [null, $ctx->make_error('point_op_allow',
+                "Operation \"{$op->name}\" not allowed by SDK option allow.op value: \"{$allow_op}\"")];
+        }
+
+        if (empty($op->points)) {
+            return [null, $ctx->make_error('point_no_points',
+                "Operation \"{$op->name}\" has no endpoint definitions.")];
+        }
+
+        if (count($op->points) === 1) {
+            $ctx->point = $op->points[0];
+        } else {
+            $reqselector = $op->input === 'data' ? $ctx->reqdata : $ctx->reqmatch;
+            $selector = $op->input === 'data' ? $ctx->data : $ctx->match;
+
+            $point = null;
+            foreach ($op->points as $p) {
+                $point = $p;
+                $select_def = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($p, 'select'));
+                $found = true;
+
+                if ($selector && $select_def) {
+                    $exist = \Voxgig\Struct\Struct::getprop($select_def, 'exist');
+                    if (is_array($exist)) {
+                        foreach ($exist as $ek) {
+                            $rv = \Voxgig\Struct\Struct::getprop($reqselector, (string)$ek);
+                            $sv = \Voxgig\Struct\Struct::getprop($selector, (string)$ek);
+                            if ($rv === null && $sv === null) {
+                                $found = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if ($found) {
+                    $req_action = \Voxgig\Struct\Struct::getprop($reqselector, '$action');
+                    $select_action = \Voxgig\Struct\Struct::getprop($select_def, '$action');
+                    if ($req_action !== $select_action) {
+                        $found = false;
+                    }
+                }
+
+                if ($found) {
+                    break;
+                }
+            }
+
+            if ($reqselector) {
+                $req_action = \Voxgig\Struct\Struct::getprop($reqselector, '$action');
+                if ($req_action && $point) {
+                    $point_select = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($point, 'select'));
+                    $point_action = \Voxgig\Struct\Struct::getprop($point_select, '$action');
+                    if ($req_action !== $point_action) {
+                        return [null, $ctx->make_error('point_action_invalid',
+                            "Operation \"{$op->name}\" action \"" . \Voxgig\Struct\Struct::stringify($req_action) . "\" is not valid.")];
+                    }
+                }
+            }
+
+            $ctx->point = $point;
+        }
+
+        return [$ctx->point, null];
+    }
+}

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

@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_request
+
+require_once __DIR__ . '/../core/Response.php';
+require_once __DIR__ . '/../core/Result.php';
+
+class ProjectNameMakeRequest
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        if (isset($ctx->out['request'])) {
+            return [$ctx->out['request'], null];
+        }
+
+        $spec = $ctx->spec;
+        $utility = $ctx->utility;
+        $response = new ProjectNameResponse([]);
+        $result = new ProjectNameResult([]);
+        $ctx->result = $result;
+
+        if (!$spec) {
+            return [null, $ctx->make_error('request_no_spec', 'Expected context spec property to be defined.')];
+        }
+
+        [$fetchdef, $err] = ($utility->make_fetch_def)($ctx);
+        if ($err) {
+            $response->err = $err;
+            $ctx->response = $response;
+            $spec->step = 'postrequest';
+            return [$response, null];
+        }
+
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain['fetchdef'] = $fetchdef;
+        }
+
+        $spec->step = 'prerequest';
+        $url = $fetchdef['url'] ?? '';
+        [$fetched, $fetch_err] = ($utility->fetcher)($ctx, $url, $fetchdef);
+
+        if ($fetch_err) {
+            $response->err = $fetch_err;
+        } elseif ($fetched === null) {
+            $response = new ProjectNameResponse(['err' => $ctx->make_error('request_no_response', 'response: undefined')]);
+        } elseif (is_array($fetched)) {
+            $response = new ProjectNameResponse($fetched);
+        } else {
+            $response->err = $ctx->make_error('request_invalid_response', 'response: invalid type');
+        }
+
+        $spec->step = 'postrequest';
+        $ctx->response = $response;
+        return [$response, null];
+    }
+}

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

@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_response
+
+class ProjectNameMakeResponse
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        if (isset($ctx->out['response'])) {
+            return [$ctx->out['response'], null];
+        }
+        $utility = $ctx->utility;
+        $spec = $ctx->spec;
+        $result = $ctx->result;
+        $response = $ctx->response;
+
+        if (!$spec) {
+            return [null, $ctx->make_error('response_no_spec', 'Expected context spec property to be defined.')];
+        }
+        if (!$response) {
+            return [null, $ctx->make_error('response_no_response', 'Expected context response property to be defined.')];
+        }
+        if (!$result) {
+            return [null, $ctx->make_error('response_no_result', 'Expected context result property to be defined.')];
+        }
+
+        $spec->step = 'response';
+        ($utility->result_basic)($ctx);
+        ($utility->result_headers)($ctx);
+        ($utility->result_body)($ctx);
+        ($utility->transform_response)($ctx);
+
+        if ($result->err === null) {
+            $result->ok = true;
+        }
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain['result'] = $result;
+        }
+
+        return [$response, null];
+    }
+}

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

@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: make_result
+
+class ProjectNameMakeResult
+{
+    public static function call(ProjectNameContext $ctx): array
+    {
+        if (isset($ctx->out['result'])) {
+            return [$ctx->out['result'], null];
+        }
+        $utility = $ctx->utility;
+        $op = $ctx->op;
+        $entity = $ctx->entity;
+        $spec = $ctx->spec;
+        $result = $ctx->result;
+
+        if (!$spec) {
+            return [null, $ctx->make_error('result_no_spec', 'Expected context spec property to be defined.')];
+        }
+        if (!$result) {
+            return [null, $ctx->make_error('result_no_result', 'Expected context result property to be defined.')];
+        }
+
+        $spec->step = 'result';
+        ($utility->transform_response)($ctx);
+
+        if ($op->name === 'list') {
+            $resdata = $result->resdata;
+            $result->resdata = [];
+            if (is_array($resdata) && !empty($resdata) && $entity) {
+                $entities = [];
+                foreach ($resdata as $entry) {
+                    $ent = $entity->make();
+                    if ($entry instanceof \stdClass) {
+                        $entry = (array)$entry;
+                    }
+                    if (is_array($entry)) {
+                        $ent->data_set($entry);
+                    }
+                    $entities[] = $ent;
+                }
+                $result->resdata = $entities;
+            }
+        }
+
+        if ($ctx->ctrl->explain) {
+            $ctx->ctrl->explain['result'] = $result;
+        }
+        return [$result, null];
+    }
+}