@flink-app/flink 0.13.3 → 0.13.5

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

@@ -0,0 +1,59 @@
+"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.__schemas = exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+var flink_1 = require("@flink-app/flink");
+exports.Route = {
+    path: "/product/:productId",
+    method: flink_1.HttpMethod.patch,
+};
+var PatchProductWithIntersection = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: {
+                    name: "Test Product",
+                    description: "Test Description",
+                    price: req.body.update || 99.99,
+                },
+            }];
+    });
+}); };
+exports.default = PatchProductWithIntersection;
+exports.__assumedHttpMethod = "patch", exports.__file = "PatchProductWithIntersection.ts", exports.__query = [], exports.__params = [{ description: "", name: "productId" }];
+exports.__schemas = { reqSchema: { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "update": { "type": "object", "additionalProperties": false }, "fullUpdate": { "type": "object", "additionalProperties": false, "properties": { "notes": { "type": "string" }, "stock": { "type": "number" }, "warehouse": { "type": "string" }, "sku": { "type": "string" }, "name": { "type": "string" }, "description": { "type": "string" }, "price": { "type": "number" } }, "required": ["notes"] }, "metadataUpdate": { "type": "object", "additionalProperties": false, "properties": { "updatedBy": { "type": "string" } }, "required": ["updatedBy"] } }, "additionalProperties": false, "definitions": {} }, resSchema: { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "name": { "type": "string" }, "description": { "type": "string" }, "price": { "type": "number" } }, "required": ["name", "description", "price"], "additionalProperties": false, "definitions": {} } };

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

@@ -0,0 +1,59 @@
+"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.__schemas = exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
+var flink_1 = require("@flink-app/flink");
+exports.Route = {
+    path: "/user/:userId",
+    method: flink_1.HttpMethod.patch,
+};
+var PatchUserWithUnion = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var req = _b.req;
+    return __generator(this, function (_c) {
+        return [2 /*return*/, {
+                data: {
+                    firstName: "Test",
+                    lastName: "User",
+                    bio: req.body.data || "Default bio",
+                },
+            }];
+    });
+}); };
+exports.default = PatchUserWithUnion;
+exports.__assumedHttpMethod = "patch", exports.__file = "PatchUserWithUnion.ts", exports.__query = [], exports.__params = [{ description: "", name: "userId" }];
+exports.__schemas = { reqSchema: { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "data": { "type": "object", "additionalProperties": false }, "profileUpdate": { "anyOf": [{ "type": "object", "properties": { "firstName": { "type": "string" }, "lastName": { "type": "string" }, "bio": { "type": "string" } }, "additionalProperties": false }, { "type": "object", "properties": { "theme": { "type": "string" }, "notifications": { "type": "boolean" }, "language": { "type": "string" } }, "additionalProperties": false }] } }, "additionalProperties": false, "definitions": {} }, resSchema: { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "firstName": { "type": "string" }, "lastName": { "type": "string" }, "bio": { "type": "string" } }, "required": ["firstName", "lastName", "bio"], "additionalProperties": false, "definitions": {} } };

package/spec/mock-project/src/handlers/PatchCar.ts

@@ -0,0 +1,25 @@
+import { Handler, HttpMethod, RouteProps } from "@flink-app/flink";
+
+export const Route: RouteProps = {
+    path: "/car/:id",
+    method: HttpMethod.patch,
+};
+
+interface Car {
+    model: string;
+    year: number;
+}
+
+type Params = { id: string };
+type PatchCarReq = Partial<Car>;
+
+const PatchCar: Handler<any, PatchCarReq, Car, Params> = async ({ req }) => {
+    return {
+        data: {
+            model: req.body.model || "Updated Model",
+            year: req.body.year || 2024,
+        },
+    };
+};
+
+export default PatchCar;

package/spec/mock-project/src/handlers/PatchOnboardingSession.ts

@@ -0,0 +1,66 @@
+import { Handler, HttpMethod, RouteProps } from "@flink-app/flink";
+
+export const Route: RouteProps = {
+    path: "/onboarding/:sessionId",
+    method: HttpMethod.patch,
+};
+
+// Simulating a complex nested structure like in your example
+interface OnboardingSession {
+    sessionId: string;
+    status: string;
+    extractedData: {
+        companyName: string;
+        orgNumber: string;
+        address: {
+            street: string;
+            city: string;
+            postalCode: string;
+        };
+        contactInfo: {
+            email: string;
+            phone: string;
+        };
+    };
+    metadata: {
+        createdAt: Date;
+        updatedAt: Date;
+    };
+}
+
+// Test case: Partial of a nested property using bracket notation
+interface PatchOnboardingSessionReq {
+    status?: string;
+    extractedData?: Partial<OnboardingSession["extractedData"]>;
+    metadata?: Partial<OnboardingSession["metadata"]>;
+}
+
+type Params = { sessionId: string };
+
+const PatchOnboardingSession: Handler<any, PatchOnboardingSessionReq, OnboardingSession, Params> = async ({ req }) => {
+    return {
+        data: {
+            sessionId: req.params.sessionId,
+            status: req.body.status || "pending",
+            extractedData: {
+                companyName: req.body.extractedData?.companyName || "Test Company",
+                orgNumber: req.body.extractedData?.orgNumber || "123456",
+                address: {
+                    street: "Main St",
+                    city: "Stockholm",
+                    postalCode: "12345",
+                },
+                contactInfo: {
+                    email: "test@example.com",
+                    phone: "+46701234567",
+                },
+            },
+            metadata: {
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            },
+        },
+    };
+};
+
+export default PatchOnboardingSession;

package/spec/mock-project/src/handlers/PatchOrderWithComplexTypes.ts

@@ -0,0 +1,79 @@
+import { Handler, HttpMethod, RouteProps } from "@flink-app/flink";
+
+export const Route: RouteProps = {
+    path: "/order/:orderId",
+    method: HttpMethod.patch,
+};
+
+// Complex nested structures for testing edge cases
+interface OrderCustomer {
+    customerId: string;
+    name: string;
+    email: string;
+    address: {
+        street: string;
+        city: string;
+        country: string;
+    };
+}
+
+interface OrderItem {
+    productId: string;
+    quantity: number;
+    price: number;
+}
+
+interface OrderItems {
+    items: Array<OrderItem>;
+    subtotal: number;
+    tax: number;
+}
+
+interface OrderShipping {
+    method: string;
+    trackingNumber: string;
+    estimatedDelivery: Date;
+}
+
+interface OrderPayment {
+    method: string;
+    status: string;
+    transactionId: string;
+}
+
+// Test case: Complex combinations of utility types
+interface PatchOrderWithComplexTypesReq {
+    // Nested indexed access - should extract OrderCustomer
+    customerCity?: Partial<OrderCustomer["address"]>;
+
+    // Omit with indexed access - should extract OrderItems
+    items?: Omit<OrderItems, "tax"> & Partial<OrderItems["subtotal"]>;
+
+    // Pick with indexed access - should extract OrderShipping
+    shipping?: Pick<OrderShipping, "method"> & Partial<OrderShipping["trackingNumber"]>;
+
+    // Union of Partial with indexed access
+    paymentOrShipping?:
+        Partial<OrderPayment["status"]> | Partial<OrderShipping["method"]>;
+
+    // Array of Partial types
+    itemUpdates?: Array<Partial<OrderItem>>;
+}
+
+type Params = { orderId: string };
+
+interface OrderResponse {
+    orderId: string;
+    status: string;
+}
+
+const PatchOrderWithComplexTypes: Handler<any, PatchOrderWithComplexTypesReq, OrderResponse, Params> = async ({ req }) => {
+    return {
+        data: {
+            orderId: req.params.orderId,
+            status: "updated",
+        },
+    };
+};
+
+export default PatchOrderWithComplexTypes;

package/spec/mock-project/src/handlers/PatchProductWithIntersection.ts

@@ -0,0 +1,49 @@
+import { Handler, HttpMethod, RouteProps } from "@flink-app/flink";
+
+export const Route: RouteProps = {
+    path: "/product/:productId",
+    method: HttpMethod.patch,
+};
+
+// Base interfaces for testing intersection types
+interface ProductDetails {
+    name: string;
+    description: string;
+    price: number;
+}
+
+interface ProductInventory {
+    stock: number;
+    warehouse: string;
+    sku: string;
+}
+
+interface ProductMetadata {
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+}
+
+// Test case: Intersection type with Partial indexed access patterns
+interface PatchProductWithIntersectionReq {
+    // Intersection of Partial types - should extract ProductDetails and ProductInventory
+    update?: Partial<ProductDetails["price"]> & Partial<ProductInventory["stock"]>;
+    // More realistic intersection pattern
+    fullUpdate?: Partial<ProductDetails> & Partial<ProductInventory> & { notes: string };
+    // Intersection with indexed access
+    metadataUpdate?: Partial<ProductMetadata["updatedAt"]> & { updatedBy: string };
+}
+
+type Params = { productId: string };
+
+const PatchProductWithIntersection: Handler<any, PatchProductWithIntersectionReq, ProductDetails, Params> = async ({ req }) => {
+    return {
+        data: {
+            name: "Test Product",
+            description: "Test Description",
+            price: (req.body.update as any) || 99.99,
+        },
+    };
+};
+
+export default PatchProductWithIntersection;

package/spec/mock-project/src/handlers/PatchUserWithUnion.ts

@@ -0,0 +1,46 @@
+import { Handler, HttpMethod, RouteProps } from "@flink-app/flink";
+
+export const Route: RouteProps = {
+    path: "/user/:userId",
+    method: HttpMethod.patch,
+};
+
+// Base interfaces for testing union types
+interface UserProfile {
+    firstName: string;
+    lastName: string;
+    bio: string;
+}
+
+interface UserSettings {
+    theme: string;
+    notifications: boolean;
+    language: string;
+}
+
+interface UserPreferences {
+    emailFrequency: string;
+    newsletter: boolean;
+}
+
+// Test case: Union type with multiple Partial indexed access patterns
+interface PatchUserWithUnionReq {
+    // Union of Partial types - should extract UserProfile, UserSettings, UserPreferences
+    data?: Partial<UserProfile["firstName"]> | Partial<UserSettings["theme"]> | Partial<UserPreferences["emailFrequency"]>;
+    // More realistic union pattern
+    profileUpdate?: Partial<UserProfile> | Partial<UserSettings>;
+}
+
+type Params = { userId: string };
+
+const PatchUserWithUnion: Handler<any, PatchUserWithUnionReq, UserProfile, Params> = async ({ req }) => {
+    return {
+        data: {
+            firstName: "Test",
+            lastName: "User",
+            bio: req.body.data as string || "Default bio",
+        },
+    };
+};
+
+export default PatchUserWithUnion;

package/spec/utils.spec.ts

@@ -1,5 +1,5 @@
 import { JSONSchema7 } from "json-schema";
-import { getJsDocComment } from "../src/utils";
+import { formatValidationErrors, getDataAtPath, getJsDocComment } from "../src/utils";
 
 describe("Utils", () => {
     describe("getJsDocComment", () => {
@@ -15,6 +15,140 @@ describe("Utils", () => {
             expect(getJsDocComment(comment)).toBe("Hello world\nThis is another line\nThis line contains a * (asterisk)");
         });
     });
+
+    describe("getDataAtPath", () => {
+        it("should extract data at root path", () => {
+            const data = { foo: "bar" };
+            expect(getDataAtPath(data, "/")).toEqual({ foo: "bar" });
+        });
+
+        it("should extract nested data", () => {
+            const data = { jobs: [{ id: 1 }, { id: 2 }, { id: 3, result: { seed: "123" } }] };
+            expect(getDataAtPath(data, "/jobs/2/result")).toEqual({ seed: "123" });
+        });
+
+        it("should return undefined for non-existent path", () => {
+            const data = { jobs: [{ id: 1 }] };
+            expect(getDataAtPath(data, "/jobs/5/result")).toBeUndefined();
+        });
+    });
+
+    describe("formatValidationErrors", () => {
+        it("should format simple validation errors with data context", () => {
+            const errors = [
+                {
+                    instancePath: "/name",
+                    schemaPath: "#/properties/name/type",
+                    keyword: "type",
+                    params: { type: "string" },
+                    message: "must be string",
+                },
+            ];
+            const data = { name: 123 };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /name');
+            expect(formatted).toContain('Data: 123');
+            expect(formatted).toContain('expected string');
+        });
+
+        it("should format missing required property errors", () => {
+            const errors = [
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "email" },
+                    message: "must have required property 'email'",
+                },
+            ];
+            const data = { user: { name: "John" } };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /user');
+            expect(formatted).toContain('Data: {"name":"John"}');
+            expect(formatted).toContain('Missing required property: email');
+        });
+
+        it("should format errors for array items", () => {
+            const errors = [
+                {
+                    instancePath: "/jobs/5/result",
+                    schemaPath: "#/properties/jobs/items/properties/result/anyOf",
+                    keyword: "anyOf",
+                    params: {},
+                    message: "must match a schema in anyOf",
+                },
+            ];
+            const data = {
+                jobs: [
+                    { result: { seed: 1 } },
+                    { result: { seed: 2 } },
+                    { result: { seed: 3 } },
+                    { result: { seed: 4 } },
+                    { result: { seed: 5 } },
+                    { result: { seed: "wrong-type" } }, // This is item 5 (0-indexed)
+                ],
+            };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            expect(formatted).toContain('Path: /jobs/5/result');
+            expect(formatted).toContain('Data: {"seed":"wrong-type"}');
+            expect(formatted).toContain('must match a schema in anyOf');
+        });
+
+        it("should truncate very long data", () => {
+            const errors = [
+                {
+                    instancePath: "/data",
+                    schemaPath: "#/properties/data/type",
+                    keyword: "type",
+                    params: { type: "string" },
+                    message: "must be string",
+                },
+            ];
+            const longString = "x".repeat(1000);
+            const data = { data: longString };
+
+            const formatted = formatValidationErrors(errors, data, 100);
+
+            expect(formatted).toContain('(truncated)');
+            expect(formatted.length).toBeLessThan(500);
+        });
+
+        it("should group multiple errors for the same path", () => {
+            const errors = [
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "email" },
+                    message: "must have required property 'email'",
+                },
+                {
+                    instancePath: "/user",
+                    schemaPath: "#/properties/user/required",
+                    keyword: "required",
+                    params: { missingProperty: "age" },
+                    message: "must have required property 'age'",
+                },
+            ];
+            const data = { user: { name: "John" } };
+
+            const formatted = formatValidationErrors(errors, data);
+
+            // Should only show the path and data once
+            const pathCount = (formatted.match(/Path: \/user/g) || []).length;
+            expect(pathCount).toBe(1);
+
+            // But should list both missing properties
+            expect(formatted).toContain('Missing required property: email');
+            expect(formatted).toContain('Missing required property: age');
+        });
+    });
 });
 
 const jsonSchemas: JSONSchema7 = {

package/src/FlinkApp.ts

@@ -19,7 +19,7 @@ import { FlinkPlugin } from "./FlinkPlugin";
 import { FlinkRepo } from "./FlinkRepo";
 import { FlinkResponse } from "./FlinkResponse";
 import generateMockData from "./mock-data-generator";
-import { getPathParams, isError } from "./utils";
+import { formatValidationErrors, getPathParams, isError } from "./utils";
 
 const ajv = new Ajv();
 addFormats(ajv);
@@ -504,9 +504,8 @@ export class FlinkApp<C extends FlinkContext> {
                     const valid = validateReq(req.body);
 
                     if (!valid) {
-                        log.warn(`${methodAndRoute}: Bad request ${JSON.stringify(validateReq.errors, null, 2)}`);
-
-                        log.debug(`Invalid json: ${JSON.stringify(req.body)}`);
+                        const formattedErrors = formatValidationErrors(validateReq.errors, req.body);
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad request\n${formattedErrors}`);
 
                         return res.status(400).json({
                             status: 400,
@@ -563,9 +562,8 @@ export class FlinkApp<C extends FlinkContext> {
                     const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
 
                     if (!valid) {
-                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response ${JSON.stringify(validateRes.errors, null, 2)}`);
-                        log.debug(`Invalid json: ${JSON.stringify(handlerRes.data)}`);
-                        // log.debug(JSON.stringify(schema, null, 2));
+                        const formattedErrors = formatValidationErrors(validateRes.errors, handlerRes.data);
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response\n${formattedErrors}`);
 
                         return res.status(500).json({
                             status: 500,

package/src/FlinkHttpHandler.ts

@@ -9,6 +9,7 @@ export enum HttpMethod {
     post = "post",
     put = "put",
     delete = "delete",
+    patch = "patch",
 }
 
 type Params = Request["params"];