blokctl 1.3.0 → 1.4.0

package/dist/scaffold-repo/sdks/java/src/test/java/com/blok/blok/validation/SchemaValidatorTest.java

@@ -0,0 +1,246 @@
+package com.blok.blok.validation;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for SchemaValidator.
+ */
+class SchemaValidatorTest {
+
+    private SchemaValidator validator;
+
+    @BeforeEach
+    void setUp() {
+        validator = new SchemaValidator();
+    }
+
+    @Test
+    void validatesStringType() {
+        Map<String, Object> schema = Map.of("type", "string");
+
+        assertTrue(validator.validate("hello", schema).isEmpty());
+        assertFalse(validator.validate(42, schema).isEmpty());
+        assertFalse(validator.validate(true, schema).isEmpty());
+    }
+
+    @Test
+    void validatesNumberType() {
+        Map<String, Object> schema = Map.of("type", "number");
+
+        assertTrue(validator.validate(42, schema).isEmpty());
+        assertTrue(validator.validate(3.14, schema).isEmpty());
+        assertFalse(validator.validate("hello", schema).isEmpty());
+    }
+
+    @Test
+    void validatesIntegerType() {
+        Map<String, Object> schema = Map.of("type", "integer");
+
+        assertTrue(validator.validate(42, schema).isEmpty());
+        assertTrue(validator.validate(42.0, schema).isEmpty());
+        assertFalse(validator.validate(3.14, schema).isEmpty());
+        assertFalse(validator.validate("hello", schema).isEmpty());
+    }
+
+    @Test
+    void validatesBooleanType() {
+        Map<String, Object> schema = Map.of("type", "boolean");
+
+        assertTrue(validator.validate(true, schema).isEmpty());
+        assertTrue(validator.validate(false, schema).isEmpty());
+        assertFalse(validator.validate("true", schema).isEmpty());
+    }
+
+    @Test
+    void validatesObjectType() {
+        Map<String, Object> schema = Map.of("type", "object");
+
+        assertTrue(validator.validate(Map.of("key", "value"), schema).isEmpty());
+        assertFalse(validator.validate("string", schema).isEmpty());
+    }
+
+    @Test
+    void validatesArrayType() {
+        Map<String, Object> schema = Map.of("type", "array");
+
+        assertTrue(validator.validate(List.of(1, 2, 3), schema).isEmpty());
+        assertFalse(validator.validate("string", schema).isEmpty());
+    }
+
+    @Test
+    void validatesRequiredFields() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "object");
+        schema.put("required", List.of("name", "age"));
+
+        Map<String, Object> valid = Map.of("name", "John", "age", 30);
+        assertTrue(validator.validate(valid, schema).isEmpty());
+
+        Map<String, Object> missing = Map.of("name", "John");
+        List<String> errors = validator.validate(missing, schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("age"));
+    }
+
+    @Test
+    void validatesProperties() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "object");
+        schema.put("properties", Map.of(
+                "name", Map.of("type", "string"),
+                "age", Map.of("type", "number")
+        ));
+
+        Map<String, Object> valid = new HashMap<>();
+        valid.put("name", "John");
+        valid.put("age", 30);
+        assertTrue(validator.validate(valid, schema).isEmpty());
+
+        Map<String, Object> invalid = new HashMap<>();
+        invalid.put("name", 123);
+        invalid.put("age", "thirty");
+        List<String> errors = validator.validate(invalid, schema);
+        assertEquals(2, errors.size());
+    }
+
+    @Test
+    void validatesEnum() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("enum", List.of("red", "green", "blue"));
+
+        assertTrue(validator.validate("red", schema).isEmpty());
+        assertTrue(validator.validate("blue", schema).isEmpty());
+
+        List<String> errors = validator.validate("yellow", schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("enum"));
+    }
+
+    @Test
+    void validatesMinLength() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "string");
+        schema.put("minLength", 3);
+
+        assertTrue(validator.validate("hello", schema).isEmpty());
+        assertTrue(validator.validate("abc", schema).isEmpty());
+
+        List<String> errors = validator.validate("ab", schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("less than minimum"));
+    }
+
+    @Test
+    void validatesMaxLength() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "string");
+        schema.put("maxLength", 5);
+
+        assertTrue(validator.validate("hello", schema).isEmpty());
+        assertTrue(validator.validate("hi", schema).isEmpty());
+
+        List<String> errors = validator.validate("toolong", schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("exceeds maximum"));
+    }
+
+    @Test
+    void validatesMinimum() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "number");
+        schema.put("minimum", 0);
+
+        assertTrue(validator.validate(5, schema).isEmpty());
+        assertTrue(validator.validate(0, schema).isEmpty());
+
+        List<String> errors = validator.validate(-1, schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("less than minimum"));
+    }
+
+    @Test
+    void validatesMaximum() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "number");
+        schema.put("maximum", 100);
+
+        assertTrue(validator.validate(50, schema).isEmpty());
+        assertTrue(validator.validate(100, schema).isEmpty());
+
+        List<String> errors = validator.validate(101, schema);
+        assertEquals(1, errors.size());
+        assertTrue(errors.get(0).contains("exceeds maximum"));
+    }
+
+    @Test
+    void validatesNestedProperties() {
+        Map<String, Object> addressSchema = new HashMap<>();
+        addressSchema.put("type", "object");
+        addressSchema.put("properties", Map.of(
+                "street", Map.of("type", "string"),
+                "zip", Map.of("type", "string")
+        ));
+
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "object");
+        schema.put("properties", Map.of("address", addressSchema));
+
+        Map<String, Object> validAddress = new HashMap<>();
+        validAddress.put("street", "123 Main St");
+        validAddress.put("zip", "12345");
+
+        Map<String, Object> valid = new HashMap<>();
+        valid.put("address", validAddress);
+        assertTrue(validator.validate(valid, schema).isEmpty());
+
+        Map<String, Object> invalidAddress = new HashMap<>();
+        invalidAddress.put("street", 123);
+
+        Map<String, Object> invalid = new HashMap<>();
+        invalid.put("address", invalidAddress);
+        List<String> errors = validator.validate(invalid, schema);
+        assertEquals(1, errors.size());
+    }
+
+    @Test
+    void nullSchemaReturnsNoErrors() {
+        assertTrue(validator.validate("anything", null).isEmpty());
+    }
+
+    @Test
+    void nullDataValidatesAsNullType() {
+        Map<String, Object> schema = Map.of("type", "null");
+        assertTrue(validator.validate(null, schema).isEmpty());
+
+        Map<String, Object> stringSchema = Map.of("type", "string");
+        assertFalse(validator.validate(null, stringSchema).isEmpty());
+    }
+
+    @Test
+    void combinedConstraints() {
+        Map<String, Object> schema = new HashMap<>();
+        schema.put("type", "object");
+        schema.put("required", List.of("name", "email"));
+        schema.put("properties", Map.of(
+                "name", Map.of("type", "string", "minLength", 1),
+                "email", Map.of("type", "string")
+        ));
+
+        Map<String, Object> valid = new HashMap<>();
+        valid.put("name", "John");
+        valid.put("email", "john@example.com");
+        assertTrue(validator.validate(valid, schema).isEmpty());
+
+        // Missing required + wrong type
+        Map<String, Object> invalid = new HashMap<>();
+        invalid.put("name", "");
+        // email is missing
+        List<String> errors = validator.validate(invalid, schema);
+        assertFalse(errors.isEmpty());
+    }
+}

package/dist/scaffold-repo/sdks/php/.rr.yaml

@@ -0,0 +1,29 @@
+version: "3"
+
+# RoadRunner configuration for the Blok PHP SDK gRPC server.
+#
+# Run with: `rr serve -c .rr.yaml` (set GRPC_PORT to override the listen port).
+# The PHP worker is `bin/serve.php` invoked with BLOK_TRANSPORT=grpc so it
+# enters the spiral/roadrunner-grpc Server::serve() loop. RoadRunner handles
+# HTTP/2 + gRPC framing in Go and dispatches each call to a PHP worker.
+
+server:
+  command: "php bin/serve.php"
+  env:
+    BLOK_TRANSPORT: grpc
+
+grpc:
+  listen: "tcp://${HOST:-0.0.0.0}:${GRPC_PORT:-10005}"
+  proto:
+    - "proto/blok/runtime/v1/runtime.proto"
+  max_send_msg_size: 16
+  max_recv_msg_size: 16
+  pool:
+    num_workers: 1
+    max_jobs: 0
+    allocate_timeout: 60s
+    destroy_timeout: 60s
+
+logs:
+  mode: development
+  level: warn

package/dist/scaffold-repo/sdks/php/Dockerfile

@@ -0,0 +1,61 @@
+# Stage 1: Install dependencies
+FROM php:8.2-cli-alpine AS builder
+
+# Install Composer
+COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
+
+WORKDIR /app
+
+# spiral/roadrunner-worker requires ext-sockets (needs linux-headers to compile on alpine)
+RUN apk add --no-cache linux-headers && docker-php-ext-install sockets
+
+# Copy composer files first for better layer caching
+COPY composer.json composer.lock* ./
+
+# Install dependencies (no dev)
+RUN composer install --no-dev --no-scripts --no-interaction --prefer-dist --optimize-autoloader --no-security-blocking
+
+# Copy source code
+COPY . .
+
+# Regenerate autoloader with all files
+RUN composer dump-autoload --optimize --no-dev
+
+# Stage 2: Production image
+FROM php:8.2-cli-alpine
+
+# The RoadRunner daemon (`rr`) is a Go binary — grab it from the official image
+# instead of downloading. It handles HTTP/2 + gRPC framing and dispatches each
+# call to the PHP worker (bin/serve.php) over goridge pipes.
+COPY --from=ghcr.io/roadrunner-server/roadrunner:2024.3.5 /usr/bin/rr /usr/bin/rr
+
+# Install required PHP extensions (none needed beyond defaults for this SDK)
+# Add ca-certificates for HTTPS requests in ApiCallNode
+RUN apk add --no-cache ca-certificates
+
+# ext-sockets is needed at runtime by spiral/roadrunner
+RUN apk add --no-cache --virtual .ext-deps linux-headers && docker-php-ext-install sockets && apk del .ext-deps
+
+WORKDIR /app
+
+# Copy built application from builder
+COPY --from=builder /app /app
+
+# HTTP port (informational /health) + gRPC port (the runner only speaks gRPC).
+EXPOSE 8080 10005
+
+# Set default environment variables
+ENV PORT=8080
+ENV HOST=0.0.0.0
+ENV GRPC_PORT=10005
+ENV VERSION=1.0.0
+ENV LOG_LEVEL=INFO
+ENV ENABLE_CORS=false
+
+# Readiness = the gRPC port accepts a TCP connection (matches the runner's probe).
+HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=5 \
+    CMD php -r "exit(@fsockopen('127.0.0.1', (int)(getenv('GRPC_PORT') ?: 10005)) ? 0 : 1);" || exit 1
+
+# Run the gRPC server via RoadRunner (rr starts `php bin/serve.php` with
+# BLOK_TRANSPORT=grpc per .rr.yaml). The runner reaches PHP only over gRPC.
+CMD ["rr", "serve", "-c", ".rr.yaml"]