blokctl 1.3.0 → 1.4.0

package/dist/scaffold-repo/sdks/java/src/main/java/com/blok/blok/types/HealthStatus.java

@@ -0,0 +1,77 @@
+package com.blok.blok.types;
+
+import com.google.gson.annotations.SerializedName;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Represents the health status of the blok runtime.
+ */
+public class HealthStatus {
+
+    private String status;
+    private String version;
+
+    @SerializedName("nodes_loaded")
+    private List<String> nodesLoaded;
+
+    public HealthStatus() {
+    }
+
+    public HealthStatus(String status, String version, List<String> nodesLoaded) {
+        this.status = status;
+        this.version = version;
+        this.nodesLoaded = nodesLoaded;
+    }
+
+    // Getters and setters
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
+    public List<String> getNodesLoaded() {
+        return nodesLoaded;
+    }
+
+    public void setNodesLoaded(List<String> nodesLoaded) {
+        this.nodesLoaded = nodesLoaded;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        HealthStatus that = (HealthStatus) o;
+        return Objects.equals(status, that.status) &&
+                Objects.equals(version, that.version) &&
+                Objects.equals(nodesLoaded, that.nodesLoaded);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(status, version, nodesLoaded);
+    }
+
+    @Override
+    public String toString() {
+        return "HealthStatus{" +
+                "status='" + status + '\'' +
+                ", version='" + version + '\'' +
+                ", nodesLoaded=" + nodesLoaded +
+                '}';
+    }
+}

package/dist/scaffold-repo/sdks/java/src/main/java/com/blok/blok/types/NodeConfig.java

@@ -0,0 +1,139 @@
+package com.blok.blok.types;
+
+import com.google.gson.annotations.SerializedName;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Represents node-specific configuration from the Blok runner.
+ */
+public class NodeConfig {
+
+    private String name;
+    private String path;
+
+    @SerializedName("type")
+    private String type;
+
+    private Map<String, Object> config;
+
+    public NodeConfig() {
+        this.config = new HashMap<>();
+    }
+
+    /**
+     * Retrieves a string config value with a default.
+     *
+     * @param key        the config key
+     * @param defaultVal the default value if key is missing or not a string
+     * @return the config value or default
+     */
+    public String getConfigString(String key, String defaultVal) {
+        if (config == null || key == null) {
+            return defaultVal;
+        }
+        Object value = config.get(key);
+        if (value instanceof String) {
+            return (String) value;
+        }
+        return defaultVal;
+    }
+
+    /**
+     * Retrieves an integer config value with a default.
+     *
+     * @param key        the config key
+     * @param defaultVal the default value if key is missing or not numeric
+     * @return the config value or default
+     */
+    public int getConfigInt(String key, int defaultVal) {
+        if (config == null || key == null) {
+            return defaultVal;
+        }
+        Object value = config.get(key);
+        if (value instanceof Number) {
+            return ((Number) value).intValue();
+        }
+        return defaultVal;
+    }
+
+    /**
+     * Retrieves a boolean config value with a default.
+     *
+     * @param key        the config key
+     * @param defaultVal the default value if key is missing or not a boolean
+     * @return the config value or default
+     */
+    public boolean getConfigBool(String key, boolean defaultVal) {
+        if (config == null || key == null) {
+            return defaultVal;
+        }
+        Object value = config.get(key);
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        return defaultVal;
+    }
+
+    // Getters and setters
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public Map<String, Object> getConfig() {
+        return config;
+    }
+
+    public void setConfig(Map<String, Object> config) {
+        this.config = config != null ? config : new HashMap<>();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        NodeConfig that = (NodeConfig) o;
+        return Objects.equals(name, that.name) &&
+                Objects.equals(path, that.path) &&
+                Objects.equals(type, that.type) &&
+                Objects.equals(config, that.config);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, path, type, config);
+    }
+
+    @Override
+    public String toString() {
+        return "NodeConfig{" +
+                "name='" + name + '\'' +
+                ", path='" + path + '\'' +
+                ", type='" + type + '\'' +
+                ", config=" + config +
+                '}';
+    }
+}

package/dist/scaffold-repo/sdks/java/src/main/java/com/blok/blok/types/Request.java

@@ -0,0 +1,154 @@
+package com.blok.blok.types;
+
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.reflect.TypeToken;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Represents the incoming HTTP request data passed through the workflow context.
+ */
+public class Request {
+
+    private Object body;
+    private Map<String, String> headers;
+    private Map<String, String> params;
+    private Map<String, String> query;
+    private String method;
+    private String url;
+    private Map<String, String> cookies;
+
+    @SerializedName("baseUrl")
+    private String baseUrl;
+
+    public Request() {
+        this.headers = new HashMap<>();
+        this.params = new HashMap<>();
+        this.query = new HashMap<>();
+        this.cookies = new HashMap<>();
+    }
+
+    /**
+     * Returns the request body as a Map, or null if the body is not a map.
+     */
+    @SuppressWarnings("unchecked")
+    public Map<String, Object> bodyMap() {
+        if (body instanceof Map) {
+            return (Map<String, Object>) body;
+        }
+        if (body == null) {
+            return null;
+        }
+        // Try to convert via Gson if it's some other type
+        try {
+            Gson gson = new Gson();
+            String json = gson.toJson(body);
+            return gson.fromJson(json, new TypeToken<Map<String, Object>>() {}.getType());
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    // Getters and setters
+
+    public Object getBody() {
+        return body;
+    }
+
+    public void setBody(Object body) {
+        this.body = body;
+    }
+
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    public void setHeaders(Map<String, String> headers) {
+        this.headers = headers != null ? headers : new HashMap<>();
+    }
+
+    public Map<String, String> getParams() {
+        return params;
+    }
+
+    public void setParams(Map<String, String> params) {
+        this.params = params != null ? params : new HashMap<>();
+    }
+
+    public Map<String, String> getQuery() {
+        return query;
+    }
+
+    public void setQuery(Map<String, String> query) {
+        this.query = query != null ? query : new HashMap<>();
+    }
+
+    public String getMethod() {
+        return method;
+    }
+
+    public void setMethod(String method) {
+        this.method = method;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public Map<String, String> getCookies() {
+        return cookies;
+    }
+
+    public void setCookies(Map<String, String> cookies) {
+        this.cookies = cookies != null ? cookies : new HashMap<>();
+    }
+
+    public String getBaseUrl() {
+        return baseUrl;
+    }
+
+    public void setBaseUrl(String baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Request request = (Request) o;
+        return Objects.equals(body, request.body) &&
+                Objects.equals(headers, request.headers) &&
+                Objects.equals(params, request.params) &&
+                Objects.equals(query, request.query) &&
+                Objects.equals(method, request.method) &&
+                Objects.equals(url, request.url) &&
+                Objects.equals(cookies, request.cookies) &&
+                Objects.equals(baseUrl, request.baseUrl);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(body, headers, params, query, method, url, cookies, baseUrl);
+    }
+
+    @Override
+    public String toString() {
+        return "Request{" +
+                "body=" + body +
+                ", headers=" + headers +
+                ", params=" + params +
+                ", query=" + query +
+                ", method='" + method + '\'' +
+                ", url='" + url + '\'' +
+                ", cookies=" + cookies +
+                ", baseUrl='" + baseUrl + '\'' +
+                '}';
+    }
+}

package/dist/scaffold-repo/sdks/java/src/main/java/com/blok/blok/types/Response.java

@@ -0,0 +1,77 @@
+package com.blok.blok.types;
+
+import java.util.Objects;
+
+/**
+ * Represents the workflow response.
+ */
+public class Response {
+
+    private Object data;
+    private String contentType;
+    private boolean success;
+    private Object error;
+
+    public Response() {
+    }
+
+    // Getters and setters
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+
+    public String getContentType() {
+        return contentType;
+    }
+
+    public void setContentType(String contentType) {
+        this.contentType = contentType;
+    }
+
+    public boolean isSuccess() {
+        return success;
+    }
+
+    public void setSuccess(boolean success) {
+        this.success = success;
+    }
+
+    public Object getError() {
+        return error;
+    }
+
+    public void setError(Object error) {
+        this.error = error;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Response response = (Response) o;
+        return success == response.success &&
+                Objects.equals(data, response.data) &&
+                Objects.equals(contentType, response.contentType) &&
+                Objects.equals(error, response.error);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(data, contentType, success, error);
+    }
+
+    @Override
+    public String toString() {
+        return "Response{" +
+                "data=" + data +
+                ", contentType='" + contentType + '\'' +
+                ", success=" + success +
+                ", error=" + error +
+                '}';
+    }
+}

package/dist/scaffold-repo/sdks/java/src/main/java/com/blok/blok/validation/SchemaValidator.java

@@ -0,0 +1,178 @@
+package com.blok.blok.validation;
+
+import com.google.gson.Gson;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Lightweight JSON Schema validator supporting a subset of JSON Schema Draft 7.
+ * <p>
+ * Supported keywords: type, required, properties, enum, minLength, maxLength,
+ * minimum, maximum.
+ */
+public class SchemaValidator {
+
+    private static final Gson GSON = new Gson();
+
+    /**
+     * Validates data against a JSON Schema.
+     *
+     * @param data   the data to validate
+     * @param schema the JSON Schema as a map
+     * @return a list of validation errors (empty if valid)
+     */
+    public List<String> validate(Object data, Map<String, Object> schema) {
+        List<String> errors = new ArrayList<>();
+        if (schema == null) {
+            return errors;
+        }
+        validateValue(data, schema, "", errors);
+        return errors;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void validateValue(Object data, Map<String, Object> schema, String path, List<String> errors) {
+        if (schema == null) {
+            return;
+        }
+
+        // Type check
+        Object schemaType = schema.get("type");
+        if (schemaType instanceof String typeStr) {
+            if (!checkType(data, typeStr)) {
+                errors.add(pathStr(path) + ": expected type \"" + typeStr + "\", got " + describeType(data));
+                return;
+            }
+        }
+
+        // Enum check
+        Object enumVal = schema.get("enum");
+        if (enumVal instanceof List<?> enumList) {
+            if (!checkEnum(data, enumList)) {
+                errors.add(pathStr(path) + ": value not in allowed enum values");
+            }
+        }
+
+        // Object properties
+        Object propsVal = schema.get("properties");
+        if (propsVal instanceof Map<?, ?> props && data instanceof Map<?, ?> dataMap) {
+            for (Map.Entry<?, ?> entry : props.entrySet()) {
+                String propName = String.valueOf(entry.getKey());
+                if (entry.getValue() instanceof Map<?, ?> propSchema) {
+                    String propPath = path.isEmpty() ? propName : path + "." + propName;
+                    Object propData = dataMap.get(propName);
+                    if (propData != null) {
+                        validateValue(propData, (Map<String, Object>) propSchema, propPath, errors);
+                    }
+                }
+            }
+        }
+
+        // Required fields
+        Object requiredVal = schema.get("required");
+        if (requiredVal instanceof List<?> requiredList && data instanceof Map<?, ?> dataMap) {
+            for (Object req : requiredList) {
+                String fieldName = String.valueOf(req);
+                if (!dataMap.containsKey(fieldName)) {
+                    errors.add(pathStr(path) + ": missing required field \"" + fieldName + "\"");
+                }
+            }
+        }
+
+        // String constraints
+        if (data instanceof String str) {
+            Object minLenVal = schema.get("minLength");
+            if (minLenVal instanceof Number minLen) {
+                if (str.length() < minLen.intValue()) {
+                    errors.add(pathStr(path) + ": string length " + str.length()
+                            + " is less than minimum " + minLen.intValue());
+                }
+            }
+            Object maxLenVal = schema.get("maxLength");
+            if (maxLenVal instanceof Number maxLen) {
+                if (str.length() > maxLen.intValue()) {
+                    errors.add(pathStr(path) + ": string length " + str.length()
+                            + " exceeds maximum " + maxLen.intValue());
+                }
+            }
+        }
+
+        // Numeric constraints
+        Double num = toDouble(data);
+        if (num != null) {
+            Object minVal = schema.get("minimum");
+            if (minVal instanceof Number minimum) {
+                if (num < minimum.doubleValue()) {
+                    errors.add(pathStr(path) + ": value " + num
+                            + " is less than minimum " + minimum.doubleValue());
+                }
+            }
+            Object maxVal = schema.get("maximum");
+            if (maxVal instanceof Number maximum) {
+                if (num > maximum.doubleValue()) {
+                    errors.add(pathStr(path) + ": value " + num
+                            + " exceeds maximum " + maximum.doubleValue());
+                }
+            }
+        }
+    }
+
+    private boolean checkType(Object data, String expectedType) {
+        if (data == null) {
+            return "null".equals(expectedType);
+        }
+        return switch (expectedType) {
+            case "string" -> data instanceof String;
+            case "number" -> data instanceof Number;
+            case "integer" -> {
+                if (data instanceof Number num) {
+                    double d = num.doubleValue();
+                    yield d == Math.floor(d) && !Double.isInfinite(d);
+                }
+                yield false;
+            }
+            case "boolean" -> data instanceof Boolean;
+            case "object" -> data instanceof Map;
+            case "array" -> data instanceof List;
+            case "null" -> false; // data is not null at this point
+            default -> true;
+        };
+    }
+
+    private boolean checkEnum(Object data, List<?> enumValues) {
+        String dataJson = GSON.toJson(data);
+        for (Object allowed : enumValues) {
+            String allowedJson = GSON.toJson(allowed);
+            if (dataJson.equals(allowedJson)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Double toDouble(Object data) {
+        if (data instanceof Number num) {
+            return num.doubleValue();
+        }
+        return null;
+    }
+
+    private String describeType(Object data) {
+        if (data == null) return "null";
+        if (data instanceof String) return "string";
+        if (data instanceof Boolean) return "boolean";
+        if (data instanceof Number) return "number";
+        if (data instanceof Map) return "object";
+        if (data instanceof List) return "array";
+        return data.getClass().getSimpleName();
+    }
+
+    private String pathStr(String path) {
+        if (path == null || path.isEmpty()) {
+            return "$";
+        }
+        return "$." + path;
+    }
+}