@flink-app/flink 1.0.0 → 2.0.0-alpha.48

package/spec/mock-project/dist/src/FlinkContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/spec/mock-project/dist/src/FlinkErrors.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFound = notFound;
+exports.conflict = conflict;
+exports.badRequest = badRequest;
+exports.unauthorized = unauthorized;
+exports.forbidden = forbidden;
+exports.internalServerError = internalServerError;
+var uuid_1 = require("uuid");
+/**
+ * Returns a 404 Not Found error response.
+ * Use when a requested resource doesn't exist (e.g., invalid ID, missing entity).
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * if (!user) return notFound("User not found");
+ * ```
+ */
+function notFound(detail, code) {
+    return {
+        status: 404,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Not Found",
+            detail: detail || "The requested resource does not exist",
+            code: code || "notFound"
+        },
+    };
+}
+/**
+ * Returns a 409 Conflict error response.
+ * Use when a request conflicts with existing data (e.g., duplicate username/email).
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * if (existingUser) return conflict("Email already registered");
+ * ```
+ */
+function conflict(detail, code) {
+    return {
+        status: 409,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Conflict",
+            detail: detail || "An identical entity exits",
+            code: code || "conflict"
+        },
+    };
+}
+/**
+ * Returns a 400 Bad Request error response.
+ * Use when the request is malformed or contains invalid data (e.g., validation errors).
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * if (!email || !password) return badRequest("Email and password are required");
+ * ```
+ */
+function badRequest(detail, code) {
+    return {
+        status: 400,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Bad Request",
+            detail: detail || "Invalid request",
+            code: code || "badRequest"
+        },
+    };
+}
+/**
+ * Returns a 401 Unauthorized error response.
+ * Use when authentication is required but missing or invalid (e.g., no token, expired token).
+ * This means "who are you?" - the user needs to identify themselves first.
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * if (!ctx.auth?.user) return unauthorized("Authentication required");
+ * ```
+ */
+function unauthorized(detail, code) {
+    return {
+        status: 401,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Unauthorized",
+            detail: detail || "Authentication required",
+            code: code || "unauthorized"
+        },
+    };
+}
+/**
+ * Returns a 403 Forbidden error response.
+ * Use when the user is authenticated but lacks permission to access the resource.
+ * This means "I know who you are, but you're not allowed to do this."
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * if (ctx.auth?.user?.role !== "admin") return forbidden("Admin access required");
+ * ```
+ */
+function forbidden(detail, code) {
+    return {
+        status: 403,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Forbidden",
+            detail: detail || "You do not have permission to access this resource",
+            code: code || "forbidden"
+        },
+    };
+}
+/**
+ * Returns a 500 Internal Server Error response.
+ * Use when an unexpected error occurs on the server side.
+ *
+ * @param detail - Optional custom error message
+ * @param code - Optional custom error code
+ * @example
+ * ```ts
+ * try { ... } catch (error) { return internalServerError("Failed to process request"); }
+ * ```
+ */
+function internalServerError(detail, code) {
+    return {
+        status: 500,
+        error: {
+            id: (0, uuid_1.v4)(),
+            title: "Internal Server Error",
+            detail: detail || "Something unexpected went wrong",
+            code: code || "internalServerError"
+        },
+    };
+}

package/spec/mock-project/dist/src/FlinkHttpHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationMode = exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["get"] = "get";
+    HttpMethod["post"] = "post";
+    HttpMethod["put"] = "put";
+    HttpMethod["delete"] = "delete";
+    HttpMethod["patch"] = "patch";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * Validation mode for handler request and response schemas.
+ *
+ * Controls whether request and/or response data is validated against JSON schemas.
+ *
+ * **Security Note:** Skipping validation can introduce security risks. Only use
+ * SkipValidation or ValidateResponse when you have implemented custom validation
+ * or the endpoint is internal/trusted.
+ *
+ * - Validate: Validate both request and response (default behavior)
+ * - SkipValidation: Skip both request and response validation
+ * - ValidateRequest: Validate only request, skip response validation
+ * - ValidateResponse: Validate only response, skip request validation
+ *
+ * @example
+ * ```typescript
+ * // Skip validation for webhook with custom signature verification
+ * export const Route: RouteProps = {
+ *   path: "/webhook",
+ *   validation: ValidationMode.SkipValidation
+ * };
+ *
+ * // Validate request but allow flexible response during development
+ * export const Route: RouteProps = {
+ *   path: "/api/data",
+ *   validation: ValidationMode.ValidateRequest
+ * };
+ * ```
+ */
+var ValidationMode;
+(function (ValidationMode) {
+    ValidationMode["Validate"] = "Validate";
+    ValidationMode["SkipValidation"] = "SkipValidation";
+    ValidationMode["ValidateRequest"] = "ValidateRequest";
+    ValidationMode["ValidateResponse"] = "ValidateResponse";
+})(ValidationMode || (exports.ValidationMode = ValidationMode = {}));

package/spec/mock-project/dist/src/FlinkJob.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/spec/mock-project/dist/src/FlinkLog.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+var node_color_log_1 = __importDefault(require("node-color-log"));
+exports.log = {
+    debug: node_color_log_1.default.debug.bind(node_color_log_1.default),
+    info: node_color_log_1.default.info.bind(node_color_log_1.default),
+    warn: node_color_log_1.default.warn.bind(node_color_log_1.default),
+    error: node_color_log_1.default.error.bind(node_color_log_1.default),
+    json: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
+            var o = args_1[_a];
+            console.log(JSON.stringify(o, null, 2));
+        }
+    },
+    bgColorLog: node_color_log_1.default.bgColorLog.bind(node_color_log_1.default),
+    fontColorLog: node_color_log_1.default.fontColorLog.bind(node_color_log_1.default),
+    setLevel: function (level) { return node_color_log_1.default.setLevel.bind(node_color_log_1.default)(level); },
+};

package/spec/mock-project/dist/src/FlinkPlugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/spec/mock-project/dist/src/FlinkRepo.js

@@ -0,0 +1,224 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlinkRepo = void 0;
+var mongodb_1 = require("mongodb");
+var FlinkRepo = /** @class */ (function () {
+    function FlinkRepo(collectionName, db, client) {
+        this.collectionName = collectionName;
+        this.db = db;
+        this.client = client;
+        this.collection = db.collection(this.collectionName);
+    }
+    Object.defineProperty(FlinkRepo.prototype, "ctx", {
+        get: function () {
+            if (!this._ctx)
+                throw new Error("Missing FlinkContext");
+            return this._ctx;
+        },
+        set: function (ctx) {
+            this._ctx = ctx;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FlinkRepo.prototype.findAll = function () {
+        return __awaiter(this, arguments, void 0, function (query) {
+            var res;
+            if (query === void 0) { query = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.collection.find(query).toArray()];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.map(this.objectIdToString)];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.getById = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.collection.findOne({ _id: this.buildId(id) })];
+                    case 1:
+                        res = _a.sent();
+                        if (res) {
+                            return [2 /*return*/, this.objectIdToString(res)];
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.getOne = function () {
+        return __awaiter(this, arguments, void 0, function (query) {
+            var res;
+            if (query === void 0) { query = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.collection.findOne(query)];
+                    case 1:
+                        res = _a.sent();
+                        if (res) {
+                            return [2 /*return*/, this.objectIdToString(res)];
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.create = function (model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.collection.insertOne(model)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, model), { _id: result.insertedId.toString() })];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.updateOne = function (id, model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var oid, _id, modelWithoutId, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        oid = this.buildId(id);
+                        _id = model._id, modelWithoutId = __rest(model, ["_id"]);
+                        return [4 /*yield*/, this.collection.updateOne({ _id: oid }, { $set: modelWithoutId })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.collection.findOne({ _id: oid })];
+                    case 2:
+                        res = _a.sent();
+                        if (res) {
+                            return [2 /*return*/, this.objectIdToString(res)];
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.updateMany = function (query, model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _id, modelWithoutId, modifiedCount;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = model, _id = _a._id, modelWithoutId = __rest(_a, ["_id"]);
+                        return [4 /*yield*/, this.collection.updateMany(query, {
+                                $set: modelWithoutId,
+                            })];
+                    case 1:
+                        modifiedCount = (_b.sent()).modifiedCount;
+                        return [2 /*return*/, modifiedCount];
+                }
+            });
+        });
+    };
+    FlinkRepo.prototype.deleteById = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var deletedCount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.collection.deleteOne({
+                            _id: this.buildId(id),
+                        })];
+                    case 1:
+                        deletedCount = (_a.sent()).deletedCount;
+                        return [2 /*return*/, deletedCount || 0];
+                }
+            });
+        });
+    };
+    /**
+     * Helper to ensure the id is always an ObjectId.
+     * If a string is passed, it will be converted to an ObjectId.
+     * If an ObjectId is passed, it will be returned as is.
+     * @param id
+     * @returns
+     */
+    FlinkRepo.prototype.buildId = function (id) {
+        var oid;
+        if (typeof id === "string") {
+            oid = new mongodb_1.ObjectId(id);
+        }
+        else if (id instanceof mongodb_1.ObjectId) {
+            oid = id;
+        }
+        else {
+            throw new Error("Invalid id type");
+        }
+        return oid;
+    };
+    FlinkRepo.prototype.objectIdToString = function (doc) {
+        if (doc && doc._id) {
+            doc._id = doc._id.toString();
+        }
+        return doc;
+    };
+    return FlinkRepo;
+}());
+exports.FlinkRepo = FlinkRepo;

package/spec/mock-project/dist/src/FlinkResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });