@flusys/nestjs-entity-builder 9.1.0 → 9.1.2

package/interfaces/definition-bundle.interface.d.ts

@@ -0,0 +1,111 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { type EntityStatus } from '../enums/entity-status.enum.js';
+import { type FieldType } from '../enums/field-type.enum.js';
+import { type IFlowSnapshot } from './flow-definition.interface.js';
+import { type ISchemaChangePlan } from '../services/schema-change.types.js';
+export declare const DEFINITION_BUNDLE_FORMAT = "flusys.entity-builder.bundle";
+export declare const DEFINITION_BUNDLE_VERSION = 1;
+export interface IBundleField {
+    id: string;
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    nullable: boolean;
+    unique: boolean;
+    isIndexed: boolean;
+    defaultValue: unknown;
+    validationRules: Record<string, unknown> | null;
+    selectOptions: unknown[] | null;
+    relationTarget: string | null;
+    order: number;
+    uiConfig: Record<string, unknown> | null;
+    isSearchable: boolean;
+    deprecated: boolean;
+}
+export interface IBundleEntity {
+    id: string;
+    code: string;
+    label: string;
+    description: string | null;
+    status: EntityStatus;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+    fields: IBundleField[];
+}
+export type IBundleFlow = IFlowSnapshot;
+export interface IDefinitionBundle {
+    format: typeof DEFINITION_BUNDLE_FORMAT;
+    version: typeof DEFINITION_BUNDLE_VERSION;
+    entities: IBundleEntity[];
+    flows: IBundleFlow[];
+}
+export interface IImportBundleRequest {
+    bundle: IDefinitionBundle;
+    deprecateMissingFields?: boolean;
+    confirm?: boolean;
+    expectedChecksum?: string;
+    expectedPlanChecksum?: string;
+}
+export interface IBundleExport {
+    bundle: IDefinitionBundle;
+    checksum: string;
+    warnings: IMessageRef[];
+}
+export type BundleStepKind = 'update_entity' | 'create_entity' | 'restore_field' | 'rename_field' | 'update_field' | 'add_field' | 'deprecate_field' | 'create_flow' | 'update_flow';
+export interface IBundleStep {
+    kind: BundleStepKind;
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+    details: Record<string, unknown>;
+    preview: ISchemaChangePlan | null;
+    warnings: IMessageRef[];
+    blockers: IMessageRef[];
+}
+export interface IBundleExtra {
+    kind: 'entity' | 'field' | 'flow';
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+}
+export interface IBundleImportPlan {
+    checksum: string;
+    planChecksum: string;
+    steps: IBundleStep[];
+    unchanged: {
+        entities: number;
+        fields: number;
+        flows: number;
+    };
+    extras: IBundleExtra[];
+    blockers: IMessageRef[];
+    destructive: boolean;
+    mayLoseData: boolean;
+}
+export interface IBundleSettings {
+    readOnly: boolean;
+    variables: string[];
+}
+export interface IGeneratedApiKey {
+    flowSlug: string;
+    nodeId: string;
+    path: string | null;
+    key: string;
+}
+export interface IBundleStepResult {
+    kind: BundleStepKind;
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+    status: 'applied' | 'failed' | 'skipped';
+    error?: IMessageRef;
+    blockers?: IMessageRef[];
+}
+export interface IBundleImportResult {
+    checksum: string;
+    completed: boolean;
+    steps: IBundleStepResult[];
+    apiKeys: IGeneratedApiKey[];
+    warnings: IMessageRef[];
+}

package/interfaces/entity-builder-module.interface.d.ts

@@ -6,6 +6,12 @@ export interface IEntityBuilderConfig extends IDataSourceServiceOptions {
     flows?: {
         allowPrivateHttp?: boolean;
     };
+    bundles?: {
+        variables?: Record<string, string>;
+    };
+    designer?: {
+        readOnly?: boolean;
+    };
 }
 export interface EntityBuilderModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;

package/interfaces/flow-definition.interface.d.ts

@@ -1,20 +1,24 @@
 import { type IIdentity } from '@flusys/nestjs-shared/interfaces';
-import { type FlowAuthMode, type FlowBodyType, type FlowRunAs, type IFlowEdge, type IFlowInputField, type IFlowNode } from '../flow-engine/flow.types.js';
+import { type IFlowEdge, type IFlowNode } from '../flow-engine/flow.types.js';
 export interface IFlowDefinition extends IIdentity {
     name: string;
     slug: string;
     description: string | null;
     isActive: boolean;
-    authMode: FlowAuthMode;
-    permissionCode: string | null;
-    runAs: FlowRunAs;
-    isTransactional: boolean;
-    timeoutMs: number;
-    rateLimitPerMinute: number;
     retainExecutions: number;
-    bodyType: FlowBodyType;
-    inputSchema: IFlowInputField[];
     nodes: IFlowNode[];
     edges: IFlowEdge[];
     version: number;
+    draft: IFlowSnapshot | null;
+}
+export declare const FLOW_VERSIONED_FIELDS: readonly ["name", "slug", "description", "isActive", "retainExecutions", "nodes", "edges"];
+export type IFlowSnapshot = Pick<IFlowDefinition, (typeof FLOW_VERSIONED_FIELDS)[number]>;
+export interface IFlowVersion {
+    id: string;
+    flowId: string;
+    version: number;
+    note: string | null;
+    publishedAt: Date;
+    publishedById: string | null;
+    definition?: IFlowSnapshot;
 }

package/interfaces/generic-record.interface.d.ts

@@ -3,12 +3,22 @@ export interface IGenericRecord extends ObjectLiteral {
     id: string;
     [key: string]: unknown;
 }
-export declare const RECORD_FILTER_OPS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "is_null", "not_null"];
+export declare const RECORD_FILTER_OPS: readonly ["eq", "ne", "ieq", "gt", "gte", "lt", "lte", "between", "not_between", "in", "not_in", "contains", "not_contains", "starts_with", "ends_with", "has_any", "has_all", "has_none", "is_empty", "not_empty", "is_null", "not_null"];
 export type RecordFilterOp = (typeof RECORD_FILTER_OPS)[number];
+export type FilterValueKind = 'none' | 'single' | 'list' | 'range';
+export declare const FILTER_OP_VALUE_KIND: Record<RecordFilterOp, FilterValueKind>;
+export declare const TEXT_FILTER_OPS: readonly RecordFilterOp[];
+export declare const LIST_FIELD_FILTER_OPS: readonly RecordFilterOp[];
+export declare const EMPTY_FILTER_OPS: readonly RecordFilterOp[];
 export interface IRecordFilterCondition {
     op: RecordFilterOp;
     value?: unknown;
 }
+export interface IFilterRange<T> {
+    from: T;
+    to: T;
+}
+export declare function isFilterRange(value: unknown): value is IFilterRange<unknown>;
 export declare const RECORD_FILTER_LIMITS: {
     readonly MAX_IN_VALUES: 100;
 };

package/interfaces/index.d.ts

@@ -3,3 +3,4 @@ export * from './entity-builder-module.interface.js';
 export * from './schema-dialect-adapter.interface.js';
 export * from './generic-record.interface.js';
 export * from './reference-provider.interface.js';
+export * from './definition-bundle.interface.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-entity-builder",
-  "version": "9.1.0",
+  "version": "9.1.2",
   "description": "Dynamic entity builder module - runtime entity/field metadata, driven DDL, and generic CRUD",
   "type": "module",
   "main": "./fesm/index.js",
@@ -75,19 +75,18 @@
     "@nestjs/common": "^12.0.0",
     "@nestjs/config": "^12.0.0",
     "@nestjs/core": "^12.0.0",
-    "@nestjs/platform-express": "^12.0.0",
+    "@nestjs/platform-express": "^12.1.2",
     "@nestjs/swagger": "^12.0.0",
     "@nestjs/typeorm": "^12.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.0",
-    "typeorm": "^0.3.0",
+    "typeorm": "^0.3.31",
     "express": "^5.0.0",
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "9.1.0",
-    "@flusys/nestjs-shared": "9.1.0",
-    "re2js": "^2.8.6",
+    "@flusys/nestjs-core": "9.1.2",
+    "@flusys/nestjs-shared": "9.1.2",
     "quickjs-emscripten": "^0.32.0"
   }
 }

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

@@ -1,4 +1,4 @@
-import { type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
+import { type IPermissionResolver, type IPermissionScope } 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';
@@ -11,12 +11,14 @@ export declare class RuleEngineService {
     private readonly permissionCache?;
     constructor(permissionResolver?: IPermissionResolver | undefined, permissionCache?: SharedPermissionCacheService | undefined);
     createPermissionResolver(user: RuleEvaluationContext['user']): IRulePermissionResolver;
+    permissionCodes(scope: IPermissionScope): Promise<string[]>;
     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>;
+    resolveHtml(expression: RuleExpression, ctx: RuleEvaluationContext): Promise<unknown>;
     private resolveLookup;
     private resolveTemplate;
     private resolveFieldReference;

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

@@ -1,10 +1,6 @@
-import { type ILoggedUserInfo, type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
-import { type SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type IPermissionSources } from '@flusys/nestjs-shared/utils';
 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 createRulePermissionResolver(user: ILoggedUserInfo | null, sources: IPermissionSources): 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

@@ -1,4 +1,2 @@
-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

@@ -1,5 +1,8 @@
+import { type IRecordFilterCondition } from '../interfaces/generic-record.interface.js';
+import { type RuleExpression } from './rule.interface.js';
 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;
+export declare function resolveFilterEntry(item: unknown, resolve: (expression: RuleExpression) => Promise<unknown>): Promise<IRecordFilterCondition>;
+export declare const isFilterValueMissing: (entry: IRecordFilterCondition) => boolean;

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

@@ -1,4 +1,4 @@
-import { type RecordFilterOp } from '../interfaces/generic-record.interface.js';
+import { type IFilterRange, 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];
@@ -30,7 +30,7 @@ export type RuleDurationUnit = (typeof RULE_DURATION_UNITS)[number];
 export type RuleLookupMode = 'exists' | 'count' | 'first';
 export interface RuleLookupFilterCondition {
     op: RecordFilterOp;
-    value?: RuleExpression;
+    value?: RuleExpression | IFilterRange<RuleExpression>;
 }
 export interface RuleLookupExpression {
     type: 'lookup';
@@ -72,7 +72,6 @@ export declare const RULE_ENGINE_LIMITS: {
     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/definition-bundle.diff.d.ts

@@ -0,0 +1,62 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { EntityStatus } from '../enums/entity-status.enum.js';
+import { type IFlowNode } from '../flow-engine/flow.types.js';
+import { type BundleStepKind, type IBundleEntity, type IBundleExtra, type IBundleField, type IBundleFlow, type IDefinitionBundle } from '../interfaces/definition-bundle.interface.js';
+export declare function canonicalJson(value: unknown): string;
+export declare const byCode: (a: string, b: string) => number;
+export declare const bundleSubject: (item: {
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+}) => string;
+export declare const bundleChecksum: (bundle: IDefinitionBundle) => string;
+export declare function stripApiKeys(nodes: IFlowNode[]): IFlowNode[];
+export declare function extractVariables(nodes: IFlowNode[], variables: Record<string, string>): IFlowNode[];
+export declare function applyVariables(nodes: IFlowNode[], variables: Record<string, string>): {
+    nodes: IFlowNode[];
+    missing: string[];
+};
+export declare function calledFlowSlugs(nodes: IFlowNode[]): string[];
+export declare function orderFlows(flows: IBundleFlow[]): IBundleFlow[];
+export interface ICurrentEntity {
+    id: string;
+    code: string;
+    label: string;
+    description: string | null;
+    status: EntityStatus;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+    fields: IBundleField[];
+}
+export interface IPlannedOperation {
+    kind: BundleStepKind;
+    entityCode: string;
+    fieldCode?: string;
+    details: Record<string, unknown>;
+    dependsOnEarlierStep: boolean;
+    entity?: IBundleEntity;
+    field?: IBundleField;
+    targetFieldId?: string;
+    changes?: Record<string, unknown>;
+    warnings?: IMessageRef[];
+}
+export interface IEntityDiff {
+    operations: IPlannedOperation[];
+    unchangedEntities: number;
+    unchangedFields: number;
+    extras: IBundleExtra[];
+    blockers: IMessageRef[];
+}
+export declare const FIELD_COMPARED_KEYS: readonly ["label", "fieldType", "nullable", "unique", "isIndexed", "defaultValue", "validationRules", "selectOptions", "relationTarget", "order", "uiConfig", "isSearchable"];
+export declare const ENTITY_COMPARED_KEYS: readonly ["label", "description", "uiConfig", "isSoftDeleteEnabled", "isAuditEnabled", "status"];
+export declare function matchDefinitions<B extends {
+    id: string;
+    code: string;
+}, C extends {
+    id: string;
+    code: string;
+}>(items: B[], current: C[]): Map<B, C>;
+export declare function diffEntities(entities: IBundleEntity[], current: ICurrentEntity[], options?: {
+    deprecateMissingFields?: boolean;
+}): IEntityDiff;

package/services/definition-bundle.file.d.ts

@@ -0,0 +1,7 @@
+import { type IDefinitionBundle } from '../interfaces/definition-bundle.interface.js';
+export interface IUploadedBundleFile {
+    buffer: Buffer;
+    size: number;
+    originalname?: string;
+}
+export declare function readBundleFile(file: IUploadedBundleFile | undefined): IDefinitionBundle;

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

@@ -0,0 +1,32 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type ExportBundleDto } from '../dtos/definition-bundle.dto.js';
+import { type IBundleExport, type IBundleImportPlan, type IBundleImportResult, type IImportBundleRequest } from '../interfaces/definition-bundle.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { FlowDefinitionService } from './flow-definition.service.js';
+import { SchemaEvolutionService } from './schema-evolution.service.js';
+import { SchemaSyncService } from './schema-sync.service.js';
+export declare class DefinitionBundleService {
+    private readonly provider;
+    private readonly config;
+    private readonly schemaSync;
+    private readonly evolution;
+    private readonly flows;
+    constructor(provider: EntityBuilderDataSourceProvider, config: EntityBuilderConfigService, schemaSync: SchemaSyncService, evolution: SchemaEvolutionService, flows: FlowDefinitionService);
+    private variables;
+    export(dto: ExportBundleDto): Promise<IBundleExport>;
+    private loadEntities;
+    planImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportPlan>;
+    private buildPlan;
+    private relationNotYetCreated;
+    private previewEntityStep;
+    private diffFlows;
+    private fieldSpec;
+    private createRequest;
+    private changeRequest;
+    applyImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportResult>;
+    private applyEntityStep;
+    private idIsFree;
+    private freeFieldIds;
+    private applyFlowStep;
+}

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

@@ -9,4 +9,6 @@ export declare class EntityBuilderConfigService implements IModuleConfigService
     isMultiTenant(): boolean;
     getOptions(): EntityBuilderModuleOptions;
     getConfig(): import("../index.js").IEntityBuilderConfig | undefined;
+    isDesignerReadOnly(): boolean;
+    getBundleVariables(): Record<string, string>;
 }

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

@@ -8,6 +8,7 @@ export interface IEntityFlowField {
     nullable?: boolean;
     defaultValue?: unknown;
     selectOptions?: unknown[] | null;
+    validationRules?: Record<string, unknown> | null;
 }
 export interface IEntityFlowSource {
     code: string;
@@ -21,7 +22,6 @@ export interface IEntityFlowTexts {
     noMatchMessage?: string;
 }
 export declare const ENTITY_FLOW_PATHS: Record<EntityFlowEndpoint, string>;
-export declare const BULK_MAX_ITEMS = 200;
 export declare const entityFlowSlug: (entityCode: string) => string;
 export declare function buildEntityFlow(entity: IEntityFlowSource, endpoints: readonly EntityFlowEndpoint[], texts?: IEntityFlowTexts): CreateFlowDefinitionDto;
 export {};

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

@@ -1,41 +1,47 @@
 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 { type ICompanyAccessResolver, type IEmailAdapter, type ILogicNode, type ILoggedUserInfo, type INotificationAdapter } 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 { type IFlowEndpoint, type IFlowSettings } from '../flow-engine/flow.types.js';
+import { type IFlowDefinition, type IFlowSnapshot, type IFlowVersion } from '../interfaces/flow-definition.interface.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 export declare const defaultFlowPermissionCode: (slug: string) => string;
+export declare const flowPermissions: (endpoint: Pick<IFlowEndpoint, "permissions">, slug: string) => ILogicNode;
 export declare const flowNotFound: () => NotFoundException;
-export declare function toFlowSettings(dto: Pick<Partial<CreateFlowDefinitionDto>, 'authMode' | 'runAs' | 'isTransactional' | 'bodyType' | 'inputSchema' | 'nodes' | 'edges' | 'timeoutMs'> & {
+export declare const isPublished: (flow: Pick<FlowDefinition, "version">) => boolean;
+export declare function snapshotOf(source: Partial<IFlowSnapshot>): IFlowSnapshot;
+export declare const workingCopy: (flow: FlowDefinition) => IFlowSnapshot;
+type FlowSettingsSource = Pick<Partial<CreateFlowDefinitionDto>, 'nodes' | 'edges'> & {
     slug: string;
-}): IFlowSettings & {
-    timeoutMs: number;
 };
+export declare function toFlowSettings(dto: FlowSettingsSource): IFlowSettings;
 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);
+    private readonly notifications?;
+    private readonly email?;
+    private readonly companyAccess?;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, companyAccess?: ICompanyAccessResolver | undefined);
     findOrFail(id: string): Promise<FlowDefinition>;
     validate(settings: IFlowSettings): Promise<IFlowValidationResult>;
     private callersOf;
     private assertNotCalled;
+    private assertCallersKept;
+    private assertCallsStillValid;
     private assertEndpointsNotCalled;
     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: {
+    assertMayTest(settings: IFlowSettings, endpoint: IFlowEndpoint | undefined, user: ILoggedUserInfo | null, run: {
         mode: 'dry_run' | 'live';
         draft: boolean;
         saved: boolean;
@@ -43,8 +49,15 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     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 convertSingleDtoToEntity(dto: CreateFlowDefinitionDto | UpdateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    publish(id: string, note: string | undefined, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    listVersions(flowId: string): Promise<IFlowVersion[]>;
+    getVersion(flowId: string, version: number): Promise<IFlowVersion>;
+    restoreVersion(flowId: string, version: number, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    discardDraft(flowId: string, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    private saveDraft;
+    private clearCaches;
     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;
 }
+export {};

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

@@ -4,7 +4,12 @@ import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.pro
 export interface IExecutionRecord {
     flowId: string | null;
     flowSlug: string;
+    flowVersion: number | null;
     trigger: 'webhook' | 'test';
+    endpoint: {
+        nodeId: string;
+        path: string | null;
+    } | null;
     mode: 'live' | 'dry_run';
     input: unknown;
     result: Pick<IFlowRunResult, 'status' | 'statusCode' | 'body' | 'error' | 'trace' | 'durationMs'>;
@@ -24,6 +29,8 @@ export declare class FlowExecutionService {
     list(query: {
         flowId?: string;
         status?: string;
+        trigger?: string;
+        endpointNodeId?: string;
         page: number;
         pageSize: number;
     }): Promise<{

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

@@ -1,4 +1,4 @@
-import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type IBranchHierarchyResolver, type ICompanyAccessResolver, type IEmailAdapter, type ILoggedUserInfo, type INotificationAdapter } 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';
@@ -12,22 +12,23 @@ export interface IFlowRunOptions {
     input: FlowInput;
     startAt?: string;
     request: Record<string, unknown>;
+    authorization?: string;
     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 companyAccess?;
+    private readonly notifications?;
+    private readonly email?;
+    private readonly branchHierarchy?;
     private readonly logger;
-    constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService);
-    run(definition: RunnableFlow, options: IFlowRunOptions): Promise<IFlowRunResult>;
+    constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService, companyAccess?: ICompanyAccessResolver | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, branchHierarchy?: IBranchHierarchyResolver | undefined);
+    run(flow: IFlowSettings, options: IFlowRunOptions): Promise<IFlowRunResult>;
     private execute;
     private limitStatementTime;
     private commitProgress;
@@ -38,4 +39,3 @@ export declare class FlowExecutorService {
     private createEnv;
     private publishPendingEvents;
 }
-export {};

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

@@ -50,7 +50,7 @@ export declare class GenericEntityService {
     private insertRow;
     private updateRow;
     private assertUpdatable;
-    delete(id: string, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<void>;
+    delete(id: string, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<'deleted' | 'purged'>;
     findById(id: string, options?: IGenericReadOptions): Promise<IGenericRecord>;
     exists(id: string, options?: IGenericReadOptions): Promise<boolean>;
     getAll(search: string | undefined, query: IGenericQuery, options?: IGenericReadOptions): Promise<{
@@ -58,6 +58,10 @@ export declare class GenericEntityService {
         total: number;
     }>;
     private applyFilter;
+    private conditionSql;
+    private listOperand;
+    private fieldTypeOf;
+    private assertOperatorFits;
     private unknownOperator;
     private invalidFilterValue;
     private applySort;

package/services/index.d.ts

@@ -19,9 +19,11 @@ export * from './reference-scanner.service.js';
 export * from './field-value-validator.js';
 export * from './database-error.mapper.js';
 export * from './flow-definition.service.js';
-export * from './flow-api-key.service.js';
 export * from './flow-execution.service.js';
 export * from './flow-executor.service.js';
 export * from './flow-runtime.service.js';
 export * from './flow-reference.provider.js';
 export * from './entity-flow-scaffold.js';
+export * from './definition-bundle.diff.js';
+export * from './definition-bundle.file.js';
+export * from './definition-bundle.service.js';

package/services/schema-evolution.service.d.ts

@@ -30,7 +30,9 @@ export declare class SchemaEvolutionService {
     private readonly permissions;
     constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService);
     plan(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
-    apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangeApplied>;
+    apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null, options?: {
+        fieldId?: string;
+    }): Promise<ISchemaChangeApplied>;
     inspect(entityDefinitionId: string): Promise<ISchemaCheckResult>;
     history(entityDefinitionId: string, limit?: number): Promise<SchemaChangeLog[]>;
     private loadEntity;

package/services/schema-sync.service.d.ts

@@ -11,6 +11,10 @@ export interface ICreatedEntity {
     definition: EntityDefinition;
     warnings: IMessageRef[];
 }
+export interface IPresetIds {
+    entityId?: string;
+    fieldIds?: Record<string, string>;
+}
 export declare class SchemaSyncService {
     private readonly dataSourceProvider;
     private readonly dialectAdapter;
@@ -24,5 +28,5 @@ export declare class SchemaSyncService {
     private createRun;
     private createEndpointFlow;
     planCreateEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
-    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ICreatedEntity>;
+    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null, ids?: IPresetIds): Promise<ICreatedEntity>;
 }