@flusys/nestjs-entity-builder 9.1.0-rc.1

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@flusys/nestjs-entity-builder",
+  "version": "9.1.0-rc.1",
+  "description": "Dynamic entity builder module - runtime entity/field metadata, driven DDL, and generic CRUD",
+  "type": "module",
+  "main": "./fesm/index.js",
+  "module": "./fesm/index.js",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "@flusys",
+    "entity-builder",
+    "dynamic-entities",
+    "ddl",
+    "schema",
+    "backendless"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js"
+    },
+    "./docs": {
+      "types": "./docs/index.d.ts",
+      "import": "./fesm/docs/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js"
+    },
+    "./enums": {
+      "types": "./enums/index.d.ts",
+      "import": "./fesm/enums/index.js"
+    },
+    "./guards": {
+      "types": "./guards/index.d.ts",
+      "import": "./fesm/guards/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js"
+    },
+    "./rule-engine": {
+      "types": "./rule-engine/index.d.ts",
+      "import": "./fesm/rule-engine/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./fesm/*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/config": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "@nestjs/platform-express": "^12.0.0",
+    "@nestjs/swagger": "^12.0.0",
+    "@nestjs/typeorm": "^12.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.0",
+    "typeorm": "^0.3.0",
+    "express": "^5.0.0",
+    "rxjs": "^7.8.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "9.1.0-rc.1",
+    "@flusys/nestjs-shared": "9.1.0-rc.1",
+    "re2js": "^2.8.6",
+    "quickjs-emscripten": "^0.32.0"
+  }
+}

package/rule-engine/index.d.ts

@@ -0,0 +1,3 @@
+export * from './rule.interface.js';
+export * from './rule-evaluation-context.interface.js';
+export * from './rule-engine.service.js';

package/rule-engine/rule-engine.service.d.ts

@@ -0,0 +1,39 @@
+import { type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type IRulePermissionResolver, type RuleEvaluationContext } from './rule-evaluation-context.interface.js';
+import { type RuleCondition, type RuleExpression, type RuleGroup } from './rule.interface.js';
+interface IEvaluationBudget {
+    lookups?: number;
+    permissions?: IRulePermissionResolver;
+}
+export declare class RuleEngineService {
+    private readonly permissionResolver?;
+    private readonly permissionCache?;
+    constructor(permissionResolver?: IPermissionResolver | undefined, permissionCache?: SharedPermissionCacheService | undefined);
+    createPermissionResolver(user: RuleEvaluationContext['user']): IRulePermissionResolver;
+    evaluateGroup(group: RuleGroup, ctx: RuleEvaluationContext, depth?: number, budget?: IEvaluationBudget): Promise<boolean>;
+    private every;
+    evaluateCondition(condition: RuleCondition, ctx: RuleEvaluationContext, budget?: IEvaluationBudget): Promise<boolean>;
+    private resolveConditionLeft;
+    private resolveConditionValue;
+    resolveExpression(expression: RuleExpression, ctx: RuleEvaluationContext, budget?: IEvaluationBudget): Promise<unknown>;
+    private resolveLookup;
+    private resolveTemplate;
+    private resolveFieldReference;
+    private getPath;
+    private resolveFunction;
+    private hasPermissions;
+    private toText;
+    private toTime;
+    private toDurationUnit;
+    private toUtcOffset;
+    private ordered;
+    private toContainerCheck;
+    private isEmptyValue;
+    private hasIntersection;
+    private toNumber;
+    private tryToNumber;
+    private applyArithmetic;
+    private assertWithinLimits;
+}
+export {};

package/rule-engine/rule-evaluation-context.interface.d.ts

@@ -0,0 +1,28 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+export interface IRuleLookupQuery {
+    filter: Record<string, unknown>;
+    sort?: Record<string, 'ASC' | 'DESC'>;
+    limit: number;
+}
+export interface IRuleLookupResolver {
+    find(entityCode: string, query: IRuleLookupQuery): Promise<{
+        rows: Record<string, unknown>[];
+        total: number;
+    }>;
+}
+export interface IRulePermissionResolver {
+    granted(branchId: string | null | undefined): Promise<string[]>;
+}
+export interface RuleEvaluationContext {
+    input?: Record<string, unknown> | unknown[];
+    context?: Record<string, Record<string, unknown>>;
+    vars?: Record<string, unknown>;
+    loop?: {
+        item: unknown;
+        index: number;
+    };
+    request?: Record<string, unknown>;
+    user: ILoggedUserInfo | null;
+    lookupResolver?: IRuleLookupResolver;
+    permissions?: IRulePermissionResolver;
+}

package/rule-engine/rule-ip.d.ts

@@ -0,0 +1,3 @@
+export declare function parseIpRanges(value: unknown): string[];
+export declare function invalidIpRange(value: unknown): string | null;
+export declare function ipInRanges(ip: unknown, ranges: unknown): boolean;

package/rule-engine/rule-permission.d.ts

@@ -0,0 +1,10 @@
+import { type ILoggedUserInfo, type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
+import { type SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type IRulePermissionResolver } from './rule-evaluation-context.interface.js';
+export interface IRulePermissionSources {
+    resolver?: IPermissionResolver;
+    cache?: SharedPermissionCacheService;
+}
+export declare function createRulePermissionResolver(user: ILoggedUserInfo | null, sources: IRulePermissionSources): IRulePermissionResolver;
+export declare function parsePermissionCodes(value: unknown): string[];
+export declare function toBranchArgument(args: unknown[], index: number): string | null | undefined;

package/rule-engine/rule-regex.d.ts

@@ -0,0 +1,4 @@
+export type RulePatternProblem = 'too_long' | 'invalid' | 'too_complex';
+export declare function rulePatternProblem(pattern: string): RulePatternProblem | null;
+export declare function matchesPattern(input: unknown, pattern: unknown): boolean;
+export declare function extractPattern(input: unknown, pattern: unknown, group?: unknown): string | null;

package/rule-engine/rule-values.d.ts

@@ -0,0 +1,5 @@
+export declare const ISO_DATE_PREFIX: RegExp;
+export declare function parseDateText(text: string): number;
+export declare function valuesEqual(a: unknown, b: unknown): boolean;
+export declare const includesValue: (list: readonly unknown[], value: unknown) => boolean;
+export declare const equalsOperand: (value: unknown) => unknown;

package/rule-engine/rule.interface.d.ts

@@ -0,0 +1,79 @@
+import { type RecordFilterOp } from '../interfaces/generic-record.interface.js';
+export type RuleLogicOperator = 'AND' | 'OR' | 'NOT';
+export declare const RULE_COMPARISON_OPERATORS: readonly ["equals", "not_equals", "greater_than", "less_than", "greater_or_equal", "less_or_equal", "contains", "not_contains", "starts_with", "ends_with", "is_empty", "is_not_empty", "in", "not_in", "is_any_of", "is_none_of", "is_true", "is_false", "matches", "not_matches"];
+export type RuleComparisonOperator = (typeof RULE_COMPARISON_OPERATORS)[number];
+export interface RuleCondition {
+    field?: string;
+    left?: RuleExpression;
+    comparison: RuleComparisonOperator;
+    value?: unknown | {
+        $field: string;
+    } | {
+        $expr: RuleExpression;
+    };
+}
+export interface RuleGroup {
+    operator: RuleLogicOperator;
+    conditions: Array<RuleCondition | RuleGroup>;
+}
+export declare function isRuleGroup(node: RuleCondition | RuleGroup): node is RuleGroup;
+export type RuleArithmeticOp = 'sum' | 'subtract' | 'multiply' | 'divide' | 'min' | 'max';
+export declare const RULE_PERMISSION_FUNCTIONS: readonly ["HAS_PERMISSION", "HAS_ANY_PERMISSION", "HAS_ALL_PERMISSIONS"];
+export type RulePermissionFunctionName = (typeof RULE_PERMISSION_FUNCTIONS)[number];
+export declare const RULE_REQUEST_FUNCTIONS: readonly ["HEADER", "QUERY_PARAM", "IP_IN_RANGE"];
+export type RuleRequestFunctionName = (typeof RULE_REQUEST_FUNCTIONS)[number];
+export type RuleTextFunctionName = 'LOWER' | 'UPPER' | 'TRIM' | 'LENGTH' | 'SPLIT_PART' | 'REGEX_EXTRACT' | 'REPLACE' | 'TO_NUMBER';
+export type RuleFunctionName = 'NOW' | 'UUID' | 'CURRENT_USER_ID' | 'COALESCE' | 'ROUND' | 'DATE_DIFF' | 'START_OF_DAY' | 'END_OF_DAY' | 'ADD_DURATION' | RulePermissionFunctionName | RuleRequestFunctionName | RuleTextFunctionName;
+export declare function isPermissionFunction(name: unknown): name is RulePermissionFunctionName;
+export declare const RULE_DURATION_UNITS: readonly ["second", "minute", "hour", "day"];
+export type RuleDurationUnit = (typeof RULE_DURATION_UNITS)[number];
+export type RuleLookupMode = 'exists' | 'count' | 'first';
+export interface RuleLookupFilterCondition {
+    op: RecordFilterOp;
+    value?: RuleExpression;
+}
+export interface RuleLookupExpression {
+    type: 'lookup';
+    entity: string;
+    filter: Record<string, RuleExpression | RuleLookupFilterCondition>;
+    mode: RuleLookupMode;
+    field?: string;
+    sort?: {
+        field: string;
+        direction: 'ASC' | 'DESC';
+    };
+}
+export type RuleExpression = {
+    type: 'literal';
+    value: string | number | boolean | null;
+} | {
+    type: 'field_ref';
+    ref: string;
+} | {
+    type: 'arithmetic';
+    op: RuleArithmeticOp;
+    operands: RuleExpression[];
+} | {
+    type: 'concat';
+    parts: RuleExpression[];
+} | {
+    type: 'function';
+    name: RuleFunctionName;
+    args: RuleExpression[];
+} | {
+    type: 'template';
+    template: string;
+} | RuleLookupExpression;
+export declare const RULE_TEMPLATE_MAX_LENGTH = 4000;
+export declare const RULE_ENGINE_LIMITS: {
+    readonly MAX_GROUP_DEPTH: 8;
+    readonly MAX_CONDITIONS_PER_GROUP: 100;
+    readonly MAX_LOOKUPS: 10;
+    readonly MAX_REGEX_PATTERN_LENGTH: 500;
+    readonly MAX_REGEX_INPUT_LENGTH: 10000;
+    readonly MAX_REGEX_REPEAT: 100;
+    readonly MAX_REGEX_REPEAT_EXPANSION: 300;
+    readonly MAX_UTC_OFFSET_MINUTES: 840;
+    readonly MAX_PERMISSION_CODES: 50;
+    readonly MAX_IP_RANGES: 100;
+};

package/services/database-error.mapper.d.ts

@@ -0,0 +1,2 @@
+export declare function mapDatabaseError(error: unknown, knownFields?: string[]): unknown;
+export declare function mapSchemaError(error: unknown): unknown;

package/services/definition-cache.service.d.ts

@@ -0,0 +1,8 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+export declare class DefinitionCacheService {
+    private readonly cacheManager;
+    private readonly utilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService);
+    clearAll(tenantId?: string): Promise<void>;
+}

package/services/entity-builder-config.service.d.ts

@@ -0,0 +1,12 @@
+import { type DatabaseMode, type ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { type IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { type EntityBuilderModuleOptions } from '../interfaces/entity-builder-module.interface.js';
+export declare class EntityBuilderConfigService implements IModuleConfigService {
+    private readonly options;
+    constructor(options: EntityBuilderModuleOptions);
+    isCompanyFeatureEnabled(tenant?: ITenantDatabaseConfig): boolean;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getOptions(): EntityBuilderModuleOptions;
+    getConfig(): import("../index.js").IEntityBuilderConfig | undefined;
+}

package/services/entity-builder-datasource.provider.d.ts

@@ -0,0 +1,24 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { type IDatabaseConfig, type ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { type Request } from 'express';
+import { DataSource, type EntitySchema, type ObjectLiteral, type QueryRunner, type Repository } from 'typeorm';
+import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+export declare class EntityBuilderDataSourceProvider extends MultiTenantDataSourceService {
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    private static readonly registeredSchemas;
+    private static readonly rebuildLocks;
+    constructor(configService: EntityBuilderConfigService, request?: Request);
+    private static buildParentOptions;
+    private get statics();
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    getDriver(): Promise<SupportedDbDriver>;
+    registerDynamicSchema(schema: EntitySchema): Promise<void>;
+    getDynamicRepository<T extends ObjectLiteral>(schema: EntitySchema<T>): Promise<Repository<T>>;
+    getQueryRunner(): Promise<QueryRunner>;
+}

package/services/entity-definition.service.d.ts

@@ -0,0 +1,17 @@
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type SelectQueryBuilder } from 'typeorm';
+import { type UpdateEntityDefinitionDto, type CreateEntityDefinitionDto } from '../dtos/entity-definition.dto.js';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { type IEntityDefinition } from '../interfaces/field-definition.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export declare class EntityDefinitionService extends ApiService<CreateEntityDefinitionDto, UpdateEntityDefinitionDto, IEntityDefinition, EntityDefinition> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    protected getSelectQuery(query: SelectQueryBuilder<EntityDefinition>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<EntityDefinition>;
+        isRaw: boolean;
+    }>;
+}

package/services/entity-flow-scaffold.d.ts

@@ -0,0 +1,26 @@
+import { type EntityFlowEndpoint } from '../config/entity-builder.constants.js';
+import { FieldType } from '../enums/field-type.enum.js';
+import { type CreateFlowDefinitionDto } from '../dtos/flow.dto.js';
+export interface IEntityFlowField {
+    code: string;
+    label?: string;
+    fieldType: FieldType;
+    nullable?: boolean;
+    defaultValue?: unknown;
+    selectOptions?: unknown[] | null;
+}
+export interface IEntityFlowSource {
+    code: string;
+    label: string;
+    fields: IEntityFlowField[];
+}
+type FlowInputLabel = 'id' | 'ids' | 'search';
+export interface IEntityFlowTexts {
+    names?: Partial<Record<EntityFlowEndpoint, string>>;
+    inputLabels?: Partial<Record<FlowInputLabel, string>>;
+    noMatchMessage?: string;
+}
+export declare const BULK_MAX_ITEMS = 200;
+export declare function entityFlowSlug(entityCode: string, endpoint: EntityFlowEndpoint): string;
+export declare function buildEntityFlow(entity: IEntityFlowSource, endpoint: EntityFlowEndpoint, texts?: IEntityFlowTexts): CreateFlowDefinitionDto;
+export {};

package/services/entity-permission.service.d.ts

@@ -0,0 +1,8 @@
+import { type IPermissionActionRegistry } from '@flusys/nestjs-shared';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+export declare class EntityPermissionService {
+    private readonly actionRegistry?;
+    constructor(actionRegistry?: IPermissionActionRegistry | undefined);
+    provisionForEntity(definition: EntityDefinition): Promise<void>;
+    deprovisionForEntity(definition: Pick<EntityDefinition, 'code'>): Promise<void>;
+}

package/services/field-definition.service.d.ts

@@ -0,0 +1,17 @@
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type SelectQueryBuilder } from 'typeorm';
+import { type UpdateFieldDefinitionDto, type CreateFieldDefinitionDto } from '../dtos/field-definition.dto.js';
+import { FieldDefinition } from '../entities/field-definition.entity.js';
+import { type IFieldDefinition } from '../interfaces/field-definition.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export declare class FieldDefinitionService extends ApiService<CreateFieldDefinitionDto, UpdateFieldDefinitionDto, IFieldDefinition, FieldDefinition> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    protected getSelectQuery(query: SelectQueryBuilder<FieldDefinition>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<FieldDefinition>;
+        isRaw: boolean;
+    }>;
+}

package/services/field-type-conversion.d.ts

@@ -0,0 +1,15 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { FieldType } from '../enums/field-type.enum.js';
+import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+export interface ITypeConversion {
+    supported: boolean;
+    reason?: IMessageRef;
+    noDbChange?: boolean;
+    using?: (column: string) => string;
+    prechecks: Array<{
+        description: IMessageRef;
+        badRowsWhere: (column: string, driver: SupportedDbDriver) => string;
+    }>;
+    lossy?: IMessageRef;
+}
+export declare function planTypeConversion(from: FieldType, to: FieldType, driver: SupportedDbDriver): ITypeConversion;

package/services/field-value-validator.d.ts

@@ -0,0 +1,17 @@
+import { type IValidationError } from '@flusys/nestjs-shared/exceptions';
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { FieldType } from '../enums/field-type.enum.js';
+export type IFieldError = IValidationError & IMessageRef;
+export interface IValidatableField {
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    nullable: boolean;
+    defaultValue: unknown;
+    selectOptions: unknown[] | null;
+    validationRules: Record<string, unknown> | null;
+}
+export declare function validateRecord(fields: IValidatableField[], values: Record<string, unknown>, mode: 'insert' | 'update'): {
+    values: Record<string, unknown>;
+    errors: IFieldError[];
+};

package/services/flow-api-key.service.d.ts

@@ -0,0 +1,31 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export type FlowApiKeyStatus = 'active' | 'revoked' | 'expired';
+export type FlowApiKeyCheck = 'valid' | 'invalid' | 'expired';
+export interface IFlowApiKeyInfo {
+    id: string;
+    flowId: string;
+    name: string;
+    keyPrefix: string;
+    isActive: boolean;
+    status: FlowApiKeyStatus;
+    expiresAt: Date | null;
+    lastUsedAt: Date | null;
+    createdAt: Date;
+}
+export declare class FlowApiKeyService {
+    private readonly provider;
+    constructor(provider: EntityBuilderDataSourceProvider);
+    private repo;
+    private assertFlowExists;
+    private findKey;
+    create(flowId: string, name: string, expiresAt: string | undefined, user: ILoggedUserInfo | null): Promise<{
+        key: string;
+        info: IFlowApiKeyInfo;
+    }>;
+    list(flowId: string): Promise<IFlowApiKeyInfo[]>;
+    revoke(id: string): Promise<void>;
+    remove(id: string): Promise<void>;
+    verify(flowId: string, presented: unknown): Promise<FlowApiKeyCheck>;
+    private info;
+}

package/services/flow-definition.service.d.ts

@@ -0,0 +1,49 @@
+import { type IPermissionActionRegistry } from '@flusys/nestjs-shared';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { type DeleteDto } from '@flusys/nestjs-shared/dtos';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { SharedPermissionCacheService, UtilsService } from '@flusys/nestjs-shared/modules';
+import { NotFoundException } from '@nestjs/common';
+import { type QueryRunner } from 'typeorm';
+import { type CreateFlowDefinitionDto, type UpdateFlowDefinitionDto } from '../dtos/flow.dto.js';
+import { FlowDefinition } from '../entities/flow-definition.entity.js';
+import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
+import { type IFlowSettings } from '../flow-engine/flow.types.js';
+import { type IFlowDefinition } from '../interfaces/flow-definition.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export declare const defaultFlowPermissionCode: (slug: string) => string;
+export declare const flowNotFound: () => NotFoundException;
+export declare function toFlowSettings(dto: Pick<Partial<CreateFlowDefinitionDto>, 'authMode' | 'runAs' | 'isTransactional' | 'bodyType' | 'inputSchema' | 'nodes' | 'edges' | 'timeoutMs'> & {
+    slug: string;
+}): IFlowSettings & {
+    timeoutMs: number;
+};
+export declare class FlowDefinitionService extends ApiService<CreateFlowDefinitionDto, UpdateFlowDefinitionDto, IFlowDefinition, FlowDefinition> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly provider;
+    private readonly permissionCache;
+    private readonly actionRegistry?;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined);
+    findOrFail(id: string): Promise<FlowDefinition>;
+    validate(settings: IFlowSettings): Promise<IFlowValidationResult>;
+    private callersOf;
+    private assertNotCalled;
+    private assertSaveable;
+    assertMayAuthor(settings: IFlowSettings, user: ILoggedUserInfo | null): Promise<void>;
+    assertMayCreate(user: ILoggedUserInfo | null): Promise<void>;
+    assertMayTest(settings: IFlowSettings & {
+        permissionCode?: string | null;
+    }, user: ILoggedUserInfo | null, run: {
+        mode: 'dry_run' | 'live';
+        draft: boolean;
+        saved: boolean;
+    }): Promise<void>;
+    private assertHasPermission;
+    protected beforeInsertOperation(dto: CreateFlowDefinitionDto | CreateFlowDefinitionDto[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected beforeUpdateOperation(dto: UpdateFlowDefinitionDto | UpdateFlowDefinitionDto[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected afterInsertOperation(entities: FlowDefinition[]): Promise<void>;
+    protected afterUpdateOperation(entities: FlowDefinition[]): Promise<void>;
+    private provisionPermissions;
+}

package/services/flow-execution.service.d.ts

@@ -0,0 +1,37 @@
+import { FlowExecution } from '../entities/flow-execution.entity.js';
+import { type IFlowRunResult, type IFlowSavePoint } from '../flow-engine/flow-run.types.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export interface IExecutionRecord {
+    flowId: string | null;
+    flowSlug: string;
+    trigger: 'webhook' | 'test';
+    mode: 'live' | 'dry_run';
+    input: unknown;
+    result: Pick<IFlowRunResult, 'status' | 'statusCode' | 'body' | 'error' | 'trace' | 'durationMs'>;
+    startedAt: Date;
+    actorId: string | null;
+    callerIp: string | null;
+    retain: number;
+}
+export declare const DRAFT_TEST_RETAIN = 200;
+export declare class FlowExecutionService {
+    private readonly provider;
+    private readonly logger;
+    private static writes;
+    constructor(provider: EntityBuilderDataSourceProvider);
+    record(entry: IExecutionRecord): Promise<void>;
+    prune(flowId: string | null, retain: number): Promise<void>;
+    list(query: {
+        flowId?: string;
+        status?: string;
+        page: number;
+        pageSize: number;
+    }): Promise<{
+        rows: FlowExecution[];
+        total: number;
+    }>;
+    get(id: string): Promise<(FlowExecution & {
+        savedUpTo: IFlowSavePoint | null;
+    }) | null>;
+    private repo;
+}

package/services/flow-executor.service.d.ts

@@ -0,0 +1,40 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { ModuleRef } from '@nestjs/core';
+import { type IFlowRunResult } from '../flow-engine/flow-run.types.js';
+import { type FlowInput, type FlowRunMode, type IFlowSettings } from '../flow-engine/flow.types.js';
+import { RuleEngineService } from '../rule-engine/index.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export interface IFlowRunOptions {
+    mode: FlowRunMode;
+    user: ILoggedUserInfo | null;
+    input: FlowInput;
+    request: Record<string, unknown>;
+    exposeDetails: boolean;
+    systemAuthorized: boolean;
+}
+export declare const flowTimeout: (timeoutMs: unknown) => number;
+type RunnableFlow = IFlowSettings & {
+    timeoutMs: number;
+};
+export declare class FlowExecutorService {
+    private readonly provider;
+    private readonly ruleEngine;
+    private readonly moduleRef;
+    private readonly permissionCache;
+    private readonly config;
+    private readonly logger;
+    constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService);
+    run(definition: RunnableFlow, options: IFlowRunOptions): Promise<IFlowRunResult>;
+    private execute;
+    private limitStatementTime;
+    private commitProgress;
+    private atomic;
+    private callFlow;
+    private findCallable;
+    private assertMayCall;
+    private createEnv;
+    private publishPendingEvents;
+}
+export {};

package/services/flow-reference.provider.d.ts

@@ -0,0 +1,13 @@
+import { type EntityManager } from 'typeorm';
+import { type IEntityReferenceProvider } from '../interfaces/reference-provider.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { type ISchemaImpact } from './schema-change.types.js';
+export declare class FlowReferenceProvider implements IEntityReferenceProvider {
+    private readonly provider;
+    constructor(provider: EntityBuilderDataSourceProvider);
+    private flows;
+    private repo;
+    findEntityReferences(entityCode: string): Promise<ISchemaImpact[]>;
+    findFieldReferences(entityCode: string, fieldCode: string): Promise<ISchemaImpact[]>;
+    rewriteFieldReferences(entityCode: string, from: string, to: string, manager?: EntityManager): Promise<number>;
+}

package/services/flow-runtime.service.d.ts

@@ -0,0 +1,29 @@
+import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { type TestFlowDto } from '../dtos/flow.dto.js';
+import { FlowDefinition } from '../entities/flow-definition.entity.js';
+import { type IFlowRunResult } from '../flow-engine/flow-run.types.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { FlowDefinitionService } from './flow-definition.service.js';
+import { FlowExecutionService } from './flow-execution.service.js';
+import { FlowExecutorService } from './flow-executor.service.js';
+export interface IFlowCaller {
+    ip: string | null;
+    headers: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    path?: string | null;
+}
+export declare function requestInfo(caller: IFlowCaller): Record<string, unknown>;
+export declare class FlowRuntimeService {
+    private readonly provider;
+    private readonly executor;
+    private readonly executions;
+    private readonly definitions;
+    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService);
+    findActive(slug: string): Promise<FlowDefinition | null>;
+    handle(flow: FlowDefinition, body: unknown, caller: IFlowCaller, user: ILoggedUserInfo | null): Promise<IFlowRunResult>;
+    testRun(dto: TestFlowDto, user: ILoggedUserInfo | null, caller: IFlowCaller): Promise<{
+        result: IFlowRunResult;
+        warnings: IMessageRef[];
+    }>;
+    private logWebhook;
+}