@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/spec/ai/agentInstructions.spec.ts

@@ -0,0 +1,358 @@
+import * as fs from "fs";
+import * as path from "path";
+import { agentInstructions } from "../../src/ai/agentInstructions";
+import { FlinkContext } from "../../src/FlinkContext";
+import { AgentExecuteContext } from "../../src/ai/FlinkAgent";
+
+describe("agentInstructions", () => {
+    let mockCtx: FlinkContext;
+    let mockAgentContext: AgentExecuteContext;
+
+    beforeEach(() => {
+        mockCtx = {} as FlinkContext;
+        mockAgentContext = {
+            agentId: "test-agent",
+            conversationId: "conv-123",
+            user: {
+                id: "user-456",
+                name: "Alice",
+                tier: "premium",
+            },
+        };
+    });
+
+    describe("path resolution", () => {
+        it("should load file from project root path", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/simple.md");
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("Simple Instructions");
+            expect(result).toContain("helpful assistant");
+        });
+
+        it("should throw error when file not found", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/nonexistent.md");
+
+            await expectAsync(callback(mockCtx, mockAgentContext)).toBeRejectedWithError(
+                /Agent instructions file not found/
+            );
+        });
+
+        it("should load YAML file as plain text", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/yaml-format.yaml");
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("role: Multi-agent orchestrator");
+            expect(result).toContain("capabilities:");
+            expect(result).toContain("delegation_rules:");
+        });
+    });
+
+    describe("template rendering", () => {
+        it("should render template with static variables", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/template.md", {
+                tier: "gold",
+                isPremium: true,
+                isBusinessHours: true,
+                tools: ["search", "create", "update"],
+            });
+
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("Name: Alice");
+            expect(result).toContain("Tier: gold");
+            expect(result).toContain("⭐ VIP CUSTOMER");
+            expect(result).not.toContain("Outside business hours");
+            expect(result).toContain("- search");
+            expect(result).toContain("- create");
+            expect(result).toContain("- update");
+        });
+
+        it("should render template with callback variables", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/template.md", (ctx, agentContext) => {
+                const hour = new Date().getHours();
+                return {
+                    tier: agentContext.user?.tier || "standard",
+                    isPremium: agentContext.user?.tier === "premium",
+                    isBusinessHours: hour >= 9 && hour < 17,
+                    tools: ["ticket-tool"],
+                };
+            });
+
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("Name: Alice");
+            expect(result).toContain("Tier: premium");
+            expect(result).toContain("⭐ VIP CUSTOMER"); // isPremium should be true
+            expect(result).toContain("- ticket-tool");
+        });
+
+        it("should support async variable callbacks", async () => {
+            const callback = agentInstructions(
+                "spec/fixtures/agent-instructions/template.md",
+                async (ctx, agentContext) => {
+                    // Simulate async operation
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+
+                    return {
+                        tier: "enterprise",
+                        isPremium: true,
+                        isBusinessHours: false,
+                        tools: ["async-tool"],
+                    };
+                }
+            );
+
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("Tier: enterprise");
+            expect(result).toContain("⭐ VIP CUSTOMER");
+            expect(result).toContain("Outside business hours");
+            expect(result).toContain("- async-tool");
+        });
+
+        it("should have access to ctx, agentContext, and user in templates", async () => {
+            // Create a test file that uses context helpers
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/context-test.md");
+            fs.writeFileSync(
+                testPath,
+                `Agent: {{agentContext.agentId}}
+User: {{user.name}}
+Conversation: {{agentContext.conversationId}}`
+            );
+
+            try {
+                const callback = agentInstructions("spec/fixtures/agent-instructions/context-test.md");
+                const result = await callback(mockCtx, mockAgentContext);
+
+                expect(result).toContain("Agent: test-agent");
+                expect(result).toContain("User: Alice");
+                expect(result).toContain("Conversation: conv-123");
+            } finally {
+                fs.unlinkSync(testPath);
+            }
+        });
+
+        it("should handle Handlebars conditionals", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/template.md", {
+                tier: "basic",
+                isPremium: false,
+                isBusinessHours: false,
+                tools: [],
+            });
+
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).not.toContain("⭐ VIP CUSTOMER"); // isPremium is false
+            expect(result).toContain("Outside business hours"); // isBusinessHours is false
+        });
+
+        it("should pass through content inside {{{{raw}}}} blocks literally", async () => {
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/raw-block-test.md");
+            fs.writeFileSync(
+                testPath,
+                `Before raw.\n{{{{raw}}}}\nThis has {{literal}} braces and {{#if things}} blocks.\n{{{{/raw}}}}\nAfter raw.`
+            );
+
+            try {
+                const callback = agentInstructions("spec/fixtures/agent-instructions/raw-block-test.md");
+                const result = await callback(mockCtx, mockAgentContext);
+
+                expect(result).toContain("Before raw.");
+                expect(result).toContain("After raw.");
+                expect(result).toContain("{{literal}}");
+                expect(result).toContain("{{#if things}}");
+            } finally {
+                fs.unlinkSync(testPath);
+            }
+        });
+
+        it("should throw clear error on template rendering failure", async () => {
+            // Create a test file with invalid Handlebars syntax
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/invalid-template.md");
+            fs.writeFileSync(testPath, "Invalid syntax: {{#if unclosed}");
+
+            try {
+                const callback = agentInstructions("spec/fixtures/agent-instructions/invalid-template.md");
+
+                await expectAsync(callback(mockCtx, mockAgentContext)).toBeRejectedWithError(/Failed to render template/);
+            } finally {
+                fs.unlinkSync(testPath);
+            }
+        });
+    });
+
+    describe("file caching", () => {
+        it("should cache file and reuse on subsequent loads", async () => {
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/cache-test.md");
+            fs.writeFileSync(testPath, "Original content");
+
+            try {
+                const callback = agentInstructions("spec/fixtures/agent-instructions/cache-test.md");
+
+                // First load
+                const result1 = await callback(mockCtx, mockAgentContext);
+                expect(result1).toContain("Original content");
+
+                // Modify file without changing mtime enough (same second)
+                // This should still use cache
+                const result2 = await callback(mockCtx, mockAgentContext);
+                expect(result2).toContain("Original content");
+                expect(result2).toBe(result1); // Should be identical
+            } finally {
+                fs.unlinkSync(testPath);
+            }
+        });
+
+        it("should reload file when mtime changes", async () => {
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/mtime-test.md");
+            fs.writeFileSync(testPath, "Version 1");
+
+            try {
+                const callback = agentInstructions("spec/fixtures/agent-instructions/mtime-test.md");
+
+                // First load
+                const result1 = await callback(mockCtx, mockAgentContext);
+                expect(result1).toContain("Version 1");
+
+                // Wait to ensure different mtime
+                await new Promise((resolve) => setTimeout(resolve, 100));
+
+                // Modify file
+                fs.writeFileSync(testPath, "Version 2");
+
+                // Second load should detect change
+                const result2 = await callback(mockCtx, mockAgentContext);
+                expect(result2).toContain("Version 2");
+                expect(result2).not.toContain("Version 1");
+            } finally {
+                fs.unlinkSync(testPath);
+            }
+        });
+    });
+
+    describe("integration with FlinkAgent", () => {
+        it("should return InstructionsCallback compatible with FlinkAgent", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/simple.md");
+
+            // Verify it's a function
+            expect(typeof callback).toBe("function");
+
+            // Verify it returns a string or promise
+            const result = callback(mockCtx, mockAgentContext);
+            expect(result instanceof Promise).toBe(true);
+
+            const resolved = await result;
+            expect(typeof resolved).toBe("string");
+        });
+
+        it("should work as FlinkAgent instructions property", async () => {
+            const TestAgent = require("../fixtures/agent-instructions/TestAgent").default;
+            const agent = new TestAgent();
+
+            // Verify instructions is a callback
+            expect(typeof agent.instructions).toBe("function");
+
+            // Execute the callback
+            const result = await agent.instructions(mockCtx, mockAgentContext);
+
+            // Verify template rendered correctly
+            expect(result).toContain("Name: Alice");
+            expect(result).toContain("Tier: premium");
+            expect(result).toContain("⭐ VIP CUSTOMER");
+            expect(result).toContain("- test-tool-1");
+            expect(result).toContain("- test-tool-2");
+        });
+
+        it("should work with no variables provided", async () => {
+            const callback = agentInstructions("spec/fixtures/agent-instructions/simple.md");
+            const result = await callback(mockCtx, mockAgentContext);
+
+            expect(result).toContain("Simple Instructions");
+            expect(typeof result).toBe("string");
+        });
+
+        it("should handle missing user gracefully", async () => {
+            const contextWithoutUser: AgentExecuteContext = {
+                agentId: "test-agent",
+                conversationId: "conv-123",
+                user: undefined,
+            };
+
+            const callback = agentInstructions("spec/fixtures/agent-instructions/template.md", {
+                tier: "none",
+                isPremium: false,
+                isBusinessHours: true,
+                tools: [],
+            });
+
+            const result = await callback(mockCtx, contextWithoutUser);
+
+            // Handlebars should handle undefined user.name gracefully
+            expect(result).toContain("Name:");
+            expect(result).toContain("Tier: none");
+        });
+    });
+
+    describe("agent-relative paths", () => {
+        it("should support agent-relative paths with ./", async () => {
+            // Create a temporary agent file and instruction file in the same directory
+            const agentDir = path.join(process.cwd(), "spec/fixtures/agent-instructions/test-agent");
+            const instructionsPath = path.join(agentDir, "instructions.md");
+
+            fs.mkdirSync(agentDir, { recursive: true });
+            fs.writeFileSync(instructionsPath, "Agent-relative instructions");
+
+            try {
+                // Note: In real usage, ./ would resolve based on the agent's file location
+                // For testing, we use the project root path since we can't easily simulate the stack trace
+                const callback = agentInstructions("spec/fixtures/agent-instructions/test-agent/instructions.md");
+                const result = await callback(mockCtx, mockAgentContext);
+
+                expect(result).toContain("Agent-relative instructions");
+            } finally {
+                fs.unlinkSync(instructionsPath);
+                fs.rmdirSync(agentDir);
+            }
+        });
+    });
+
+    describe("error handling", () => {
+        it("should provide clear error with both absolute and original path on file not found", async () => {
+            const callback = agentInstructions("does/not/exist.md");
+
+            try {
+                await callback(mockCtx, mockAgentContext);
+                fail("Should have thrown error");
+            } catch (err: any) {
+                expect(err.message).toContain("Agent instructions file not found");
+                expect(err.message).toContain("does/not/exist.md"); // Original path
+                expect(err.message).toMatch(/\//); // Should contain absolute path
+            }
+        });
+
+        it("should provide clear error on file read failure", async () => {
+            const testPath = path.join(process.cwd(), "spec/fixtures/agent-instructions/readonly-test.md");
+            fs.writeFileSync(testPath, "Content");
+
+            try {
+                // Make file unreadable (skip on Windows where chmod may not work as expected)
+                if (process.platform !== "win32") {
+                    fs.chmodSync(testPath, 0o000);
+
+                    const callback = agentInstructions("spec/fixtures/agent-instructions/readonly-test.md");
+
+                    await expectAsync(callback(mockCtx, mockAgentContext)).toBeRejectedWithError(
+                        /Failed to load agent instructions file/
+                    );
+                }
+            } finally {
+                // Restore permissions and clean up
+                if (process.platform !== "win32") {
+                    fs.chmodSync(testPath, 0o644);
+                }
+                fs.unlinkSync(testPath);
+            }
+        });
+    });
+});

package/spec/fixtures/agent-instructions/TestAgent.ts

@@ -0,0 +1,24 @@
+import { FlinkAgent, agentInstructions } from "../../../src/ai";
+import { FlinkContext } from "../../../src/FlinkContext";
+
+export default class TestAgent extends FlinkAgent<FlinkContext> {
+    id = "test-agent";
+    description = "Test agent for agentInstructions integration";
+
+    // Load instructions from file using project-root path
+    // Note: For relative paths (./) to work, they must be called from the agent file itself
+    // Since this is loaded via require() from test, we use project-root path
+    instructions(ctx: FlinkContext, agentContext: any) {
+        return agentInstructions(
+            "spec/fixtures/agent-instructions/template.md",
+            (ctx, agentContext) => ({
+                tier: agentContext.user?.tier || "basic",
+                isPremium: agentContext.user?.tier === "premium",
+                isBusinessHours: true,
+                tools: ["test-tool-1", "test-tool-2"],
+            })
+        )(ctx, agentContext);
+    }
+
+    tools = [];
+}

package/spec/fixtures/agent-instructions/simple.md

@@ -0,0 +1,3 @@
+# Simple Instructions
+
+You are a helpful assistant with basic capabilities.

package/spec/fixtures/agent-instructions/template.md

@@ -0,0 +1,18 @@
+# Support Agent Instructions
+
+Customer Profile:
+- Name: {{user.name}}
+- Tier: {{tier}}
+
+{{#if isPremium}}
+⭐ VIP CUSTOMER - Provide white-glove service!
+{{/if}}
+
+{{#unless isBusinessHours}}
+NOTE: Outside business hours.
+{{/unless}}
+
+Available Tools:
+{{#each tools}}
+- {{this}}
+{{/each}}

package/spec/fixtures/agent-instructions/yaml-format.yaml

@@ -0,0 +1,9 @@
+role: Multi-agent orchestrator
+capabilities:
+  - Analyzing user requests
+  - Selecting specialist agents
+  - Coordinating workflows
+
+delegation_rules:
+  pricing: Use CarPricingAgent
+  recommendations: Use CarRecommendationAgent

package/spec/mock-project/dist/.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.6.2"}

package/spec/mock-project/dist/spec/mock-project/src/handlers/GetCar.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+var flink_1 = require("@flink-app/flink");
+exports.Route = {
+    path: "/car/:id",
+    method: flink_1.HttpMethod.get,
+};
+var GetCar = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var ctx = _b.ctx, req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: {
+                    model: "Volvo",
+                },
+            }];
+    });
+}); };
+exports.default = GetCar;
+exports.__assumedHttpMethod = "get", exports.__file = "GetCar.ts", exports.__query = [{ description: "For pagination", name: "page" }], exports.__params = [];

package/spec/mock-project/dist/spec/mock-project/src/handlers/GetCar2.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+var flink_1 = require("@flink-app/flink");
+exports.Route = {
+    path: "/car2",
+    method: flink_1.HttpMethod.get,
+    permissions: "*",
+};
+var GetCar2 = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var ctx = _b.ctx, req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: {
+                    model: { name: "Mercedes" },
+                    engine: { name: "Rolls Royce" },
+                },
+            }];
+    });
+}); };
+exports.default = GetCar2;
+exports.__assumedHttpMethod = "get", exports.__file = "GetCar2.ts", exports.__query = [], exports.__params = [];

package/spec/mock-project/dist/spec/mock-project/src/handlers/GetCarWithArraySchema.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+exports.Route = {
+    path: "/car-with-array-schema",
+};
+var GetCarWithArraySchema = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var ctx = _b.ctx, req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: [{ model: "Volvo" }],
+            }];
+    });
+}); };
+exports.default = GetCarWithArraySchema;
+exports.__assumedHttpMethod = "get", exports.__file = "GetCarWithArraySchema.ts", exports.__query = [], exports.__params = [];

package/spec/mock-project/dist/spec/mock-project/src/handlers/GetCarWithArraySchema2.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+exports.Route = {
+    path: "/car-with-array-schema2",
+};
+var GetCarWithArraySchema2 = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var ctx = _b.ctx, req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: [{ car: { model: "Volvo" } }],
+            }];
+    });
+}); };
+exports.default = GetCarWithArraySchema2;
+exports.__assumedHttpMethod = "get", exports.__file = "GetCarWithArraySchema2.ts", exports.__query = [], exports.__params = [];