@flusys/nestjs-entity-builder 9.0.0

package/fesm/enums/index.js

@@ -0,0 +1,97 @@
+export const __rspack_esm_id = 743;
+export const __rspack_esm_ids = [743];
+export const __webpack_modules__ = {
+9949(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/** Structural operations recorded by SchemaChangeLog. */ var DdlOperation = /*#__PURE__*/ function(DdlOperation) {
+    DdlOperation["CREATE_TABLE"] = "CREATE_TABLE";
+    DdlOperation["ADD_COLUMN"] = "ADD_COLUMN";
+    DdlOperation["CREATE_INDEX"] = "CREATE_INDEX";
+    DdlOperation["MARK_DEPRECATED"] = "MARK_DEPRECATED";
+    DdlOperation["RESTORE_FIELD"] = "RESTORE_FIELD";
+    DdlOperation["ALTER_FIELD"] = "ALTER_FIELD";
+    DdlOperation["RENAME_FIELD"] = "RENAME_FIELD";
+    DdlOperation["DROP_COLUMN"] = "DROP_COLUMN";
+    DdlOperation["ALTER_ENTITY"] = "ALTER_ENTITY";
+    DdlOperation["DROP_TABLE"] = "DROP_TABLE";
+    DdlOperation["REPAIR"] = "REPAIR";
+    return DdlOperation;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  i: () => (DdlOperation)
+});
+
+
+},
+1313(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Lifecycle status of an EntityDefinition.
+ * DRAFT - metadata created, table not yet materialized.
+ * ACTIVE - table exists; flows read and write its records.
+ * DEPRECATED - no new writes; physical table/data left intact.
+ */ var EntityStatus = /*#__PURE__*/ function(EntityStatus) {
+    EntityStatus["DRAFT"] = "DRAFT";
+    EntityStatus["ACTIVE"] = "ACTIVE";
+    EntityStatus["DEPRECATED"] = "DEPRECATED";
+    return EntityStatus;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  c: () => (EntityStatus)
+});
+
+
+},
+9614(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Storable field types a FieldDefinition can declare.
+ * Mapped to a driver-specific column type by SchemaDialectAdapterService.
+ */ var FieldType = /*#__PURE__*/ function(FieldType) {
+    FieldType["TEXT"] = "TEXT";
+    FieldType["LONG_TEXT"] = "LONG_TEXT";
+    FieldType["INTEGER"] = "INTEGER";
+    FieldType["DECIMAL"] = "DECIMAL";
+    FieldType["BOOLEAN"] = "BOOLEAN";
+    FieldType["DATE"] = "DATE";
+    FieldType["DATETIME"] = "DATETIME";
+    FieldType["EMAIL"] = "EMAIL";
+    FieldType["SINGLE_SELECT"] = "SINGLE_SELECT";
+    FieldType["MULTI_SELECT"] = "MULTI_SELECT";
+    FieldType["RELATION"] = "RELATION";
+    FieldType["JSON"] = "JSON";
+    FieldType["FILE"] = "FILE";
+    return FieldType;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  P: () => (FieldType)
+});
+
+
+},
+6188(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _field_type_enum_js__rspack_import_0 = __webpack_require__(9614);
+/* import */ var _entity_status_enum_js__rspack_import_1 = __webpack_require__(1313);
+/* import */ var _ddl_operation_enum_js__rspack_import_2 = __webpack_require__(9949);
+
+
+
+
+__webpack_require__.d(__webpack_exports__, {
+  PU: () => (/* reexport safe */ _field_type_enum_js__rspack_import_0.P),
+  cx: () => (/* reexport safe */ _entity_status_enum_js__rspack_import_1.c),
+  iq: () => (/* reexport safe */ _ddl_operation_enum_js__rspack_import_2.i)
+});
+
+
+},
+
+};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from './index.js';
+__webpack_require__.C(__rspack_chunk_1);
+var __webpack_exports__ = __webpack_exec__(6188);var __webpack_exports__DdlOperation = __webpack_exports__.iq;
+var __webpack_exports__EntityStatus = __webpack_exports__.cx;
+var __webpack_exports__FieldType = __webpack_exports__.PU;
+export { __webpack_exports__DdlOperation as DdlOperation, __webpack_exports__EntityStatus as EntityStatus, __webpack_exports__FieldType as FieldType };

package/fesm/guards/index.js

@@ -0,0 +1,226 @@
+import { lastValueFrom } from "rxjs";
+import * as __rspack_external__flusys_nestjs_shared_guards_3f79ddd1 from "@flusys/nestjs-shared/guards";
+export const __rspack_esm_id = 333;
+export const __rspack_esm_ids = [333];
+export const __webpack_modules__ = {
+4196(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  C: () => (/* binding */ FlowAccessGuard)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(9140);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/guards"
+var guards_ = __webpack_require__(3513);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(1236);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(6157);
+// EXTERNAL MODULE: external "@nestjs/core"
+var core_ = __webpack_require__(3075);
+;// CONCATENATED MODULE: external "rxjs"
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
+var message_keys = __webpack_require__(5732);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts + 1 modules
+var flow_definition_service = __webpack_require__(4921);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-runtime.service.ts
+var flow_runtime_service = __webpack_require__(2300);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-rate-limiter.ts
+const WINDOW_MS = 60_000;
+const DEFAULT_MAX_KEYS = 10_000;
+/**
+ * Fixed-window counter per key (flow + caller IP). In memory, so each server instance counts on
+ * its own - a guard against floods and brute-forcing of API keys, not an exact global quota.
+ * A window is re-inserted when it starts, so the map stays ordered by expiry: expired windows are
+ * dropped from the front in amortized O(1), and at `maxKeys` the oldest window is evicted.
+ */ class FlowRateLimiter {
+    maxKeys;
+    windows = new Map();
+    constructor(maxKeys = DEFAULT_MAX_KEYS){
+        this.maxKeys = maxKeys;
+    }
+    /** @returns true if the call is allowed. limit 0 = unlimited. */ hit(key, limitPerMinute, now = Date.now()) {
+        if (limitPerMinute <= 0) return true;
+        this.dropExpired(now);
+        const current = this.windows.get(key);
+        if (current && current.resetAt > now) {
+            current.count++;
+            return current.count <= limitPerMinute;
+        }
+        if (current) this.windows.delete(key);
+        if (this.windows.size >= this.maxKeys) this.windows.delete(this.windows.keys().next().value);
+        this.windows.set(key, {
+            count: 1,
+            resetAt: now + WINDOW_MS
+        });
+        return true;
+    }
+    get size() {
+        return this.windows.size;
+    }
+    dropExpired(now) {
+        for (const [key, window] of this.windows){
+            if (window.resetAt > now) return;
+            this.windows.delete(key);
+        }
+    }
+}
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-api-key.ts
+var flow_api_key = __webpack_require__(4816);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow.types.ts
+var flow_types = __webpack_require__(6256);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/guards/flow-access.guard.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+const limiter = new FlowRateLimiter();
+class FlowAccessGuard {
+    moduleRef;
+    permissionCache;
+    jwtGuard;
+    constructor(moduleRef, permissionCache){
+        this.moduleRef = moduleRef;
+        this.permissionCache = permissionCache;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const slug = request.params?.slug;
+        const contextId = core_.ContextIdFactory.getByRequest(request);
+        const runtime = await this.moduleRef.resolve(flow_runtime_service/* .FlowRuntimeService */.a, contextId, {
+            strict: false
+        });
+        const flow = slug ? await runtime.findActive(slug) : null;
+        const endpoint = flow ? (0,flow_types/* .findEndpoint */.vS)(flow, request.params?.endpoint) : undefined;
+        // A Request step for other flows only has no URL: it looks the same as an unknown one.
+        if (!flow || !endpoint || endpoint.authMode === 'internal') throw new common_.NotFoundException({
+            message: 'Not found',
+            messageKey: message_keys/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
+        });
+        request.flowDefinition = flow;
+        request.flowEndpoint = endpoint;
+        const ip = request.ip ?? request.socket?.remoteAddress ?? 'unknown';
+        if (!limiter.hit(`${flow.id}|${endpoint.nodeId}|${ip}`, endpoint.rateLimitPerMinute)) {
+            throw new common_.HttpException({
+                message: 'Too many requests. Try again in a minute.',
+                messageKey: message_keys/* .FLOW_MESSAGES.RATE_LIMITED */.wu.RATE_LIMITED
+            }, common_.HttpStatus.TOO_MANY_REQUESTS);
+        }
+        switch(endpoint.authMode){
+            case 'public':
+                return true;
+            case 'api_key':
+                {
+                    const header = request.headers?.['x-api-key'];
+                    if (!(0,flow_api_key/* .apiKeyOpens */.NT)(endpoint.apiKey, Array.isArray(header) ? header[0] : header)) {
+                        throw new common_.UnauthorizedException({
+                            message: 'A valid API key is required (x-api-key header).',
+                            messageKey: message_keys/* .FLOW_MESSAGES.API_KEY_INVALID */.wu.API_KEY_INVALID
+                        });
+                    }
+                    return true;
+                }
+            case 'jwt':
+                if (!await this.authenticate(context)) return false;
+                return true;
+            case 'permission':
+                {
+                    if (!await this.authenticate(context)) return false;
+                    await this.permissionCache.assertPermission(request.user, endpoint.permissionCode || (0,flow_definition_service/* .defaultFlowPermissionCode */.Er)(flow.slug));
+                    return true;
+                }
+            default:
+                throw new common_.UnauthorizedException({
+                    message: 'Authentication required',
+                    messageKey: constants_.ERROR_MESSAGES.UNAUTHORIZED
+                });
+        }
+    }
+    async authenticate(context) {
+        this.jwtGuard ??= await this.moduleRef.create(guards_.JwtAuthGuard);
+        const result = this.jwtGuard.canActivate(context);
+        if (typeof result === 'boolean') return result;
+        if (result instanceof Promise) return result;
+        return lastValueFrom(result);
+    }
+}
+FlowAccessGuard = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(core_.ModuleRef)),
+    _ts_param(1, (0,common_.Inject)(modules_.SharedPermissionCacheService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof core_.ModuleRef === "undefined" ? Object : core_.ModuleRef,
+        typeof modules_.SharedPermissionCacheService === "undefined" ? Object : modules_.SharedPermissionCacheService
+    ])
+], FlowAccessGuard);
+
+
+},
+5460(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flow_access_guard_js__rspack_import_0 = __webpack_require__(4196);
+
+
+__webpack_require__.d(__webpack_exports__, {
+  C: () => (/* reexport safe */ _flow_access_guard_js__rspack_import_0.C)
+});
+
+
+},
+3513(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_guards_3f79ddd1;
+
+
+},
+
+};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from '../21.js';
+__webpack_require__.C(__rspack_chunk_1);
+import * as __rspack_chunk_2 from '../582.js';
+__webpack_require__.C(__rspack_chunk_2);
+import * as __rspack_chunk_3 from '../794.js';
+__webpack_require__.C(__rspack_chunk_3);
+import * as __rspack_chunk_4 from '../677.js';
+__webpack_require__.C(__rspack_chunk_4);
+import * as __rspack_chunk_5 from './index.js';
+__webpack_require__.C(__rspack_chunk_5);
+var __webpack_exports__ = __webpack_exec__(5460);var __webpack_exports__FlowAccessGuard = __webpack_exports__.C;
+export { __webpack_exports__FlowAccessGuard as FlowAccessGuard };